int OPTIMIZER::FlipCoin(void) {
return( Rand(0.0,1.0) < 0.5 );
}
// Create a new UDP acceleration function
UDP_ACCEL *NewUdpAccel(CEDAR *cedar, IP *ip, bool client_mode, bool random_port, bool no_nat_t)
{
UDP_ACCEL *a;
SOCK *s;
UINT max_udp_size;
bool is_in_cedar_port_list = false;
if (IsZeroIP(ip))
{
ip = NULL;
}
if (client_mode || random_port)
{
// Use a appropriate vacant port number in the case of using random port or client mode
s = NewUDPEx3(0, ip);
}
else
{
// Specify in the range in the case of server mode
UINT i;
s = NULL;
LockList(cedar->UdpPortList);
{
for (i = UDP_SERVER_PORT_LOWER;i <= UDP_SERVER_PORT_HIGHER;i++)
{
if (IsIntInList(cedar->UdpPortList, i) == false)
{
s = NewUDPEx3(i, ip);
if (s != NULL)
{
is_in_cedar_port_list = true;
break;
}
}
}
if (s == NULL)
{
// Leave the port selection to the OS because the available port is not found within the range
s = NewUDPEx3(0, ip);
}
if (s != NULL && is_in_cedar_port_list)
{
AddIntDistinct(cedar->UdpPortList, i);
}
}
UnlockList(cedar->UdpPortList);
}
if (s == NULL)
{
return NULL;
}
a = ZeroMalloc(sizeof(UDP_ACCEL));
a->Cedar = cedar;
AddRef(a->Cedar->ref);
a->NoNatT = no_nat_t;
a->NatT_TranId = Rand64();
a->CreatedTick = Tick64();
a->IsInCedarPortList = is_in_cedar_port_list;
a->ClientMode = client_mode;
a->Now = Tick64();
a->UdpSock = s;
Rand(a->MyKey, sizeof(a->MyKey));
Rand(a->YourKey, sizeof(a->YourKey));
Copy(&a->MyIp, ip, sizeof(IP));
a->MyPort = s->LocalPort;
a->IsIPv6 = IsIP6(ip);
a->RecvBlockQueue = NewQueue();
Rand(a->NextIv, sizeof(a->NextIv));
do
{
a->MyCookie = Rand32();
}
while (a->MyCookie == 0);
do
{
a->YourCookie = Rand32();
}
while (a->MyCookie == 0 || a->MyCookie == a->YourCookie);
// Calculate the maximum transmittable UDP packet size
max_udp_size = MTU_FOR_PPPOE;
if (a->IsIPv6 == false)
{
// IPv4
max_udp_size -= 20;
}
else
{
// IPv6
max_udp_size -= 40;
}
// UDP
max_udp_size -= 8;
a->MaxUdpPacketSize = max_udp_size;
Debug("Udp Accel My Port = %u\n", a->MyPort);
// Initialize the NAT-T server IP address acquisition thread
a->NatT_Lock = NewLock();
a->NatT_HaltEvent = NewEvent();
if (a->NoNatT == false)
{
a->NatT_GetIpThread = NewThread(NatT_GetIpThread, a);
}
return a;
}
void DataTransformer<Dtype>::Transform(Blob<Dtype>* input_blob,
Blob<Dtype>* transformed_blob) {
const int crop_size = param_.crop_size();
const int input_num = input_blob->num();
const int input_channels = input_blob->channels();
const int input_height = input_blob->height();
const int input_width = input_blob->width();
if (transformed_blob->count() == 0) {
// Initialize transformed_blob with the right shape.
if (crop_size) {
transformed_blob->Reshape(input_num, input_channels,
crop_size, crop_size);
} else {
transformed_blob->Reshape(input_num, input_channels,
input_height, input_width);
}
}
const int num = transformed_blob->num();
const int channels = transformed_blob->channels();
const int height = transformed_blob->height();
const int width = transformed_blob->width();
const int size = transformed_blob->count();
CHECK_LE(input_num, num);
CHECK_EQ(input_channels, channels);
CHECK_GE(input_height, height);
CHECK_GE(input_width, width);
const Dtype scale = param_.scale();
const bool do_mirror = param_.mirror() && Rand(2);
const bool has_mean_file = param_.has_mean_file();
const bool has_mean_values = mean_values_.size() > 0;
int h_off = 0;
int w_off = 0;
if (crop_size) {
CHECK_EQ(crop_size, height);
CHECK_EQ(crop_size, width);
// We only do random crop when we do training.
if (phase_ == TRAIN) {
h_off = Rand(input_height - crop_size + 1);
w_off = Rand(input_width - crop_size + 1);
} else {
h_off = (input_height - crop_size) / 2;
w_off = (input_width - crop_size) / 2;
}
} else {
CHECK_EQ(input_height, height);
CHECK_EQ(input_width, width);
}
Dtype* input_data = input_blob->mutable_cpu_data();
if (has_mean_file) {
CHECK_EQ(input_channels, data_mean_.channels());
CHECK_EQ(input_height, data_mean_.height());
CHECK_EQ(input_width, data_mean_.width());
for (int n = 0; n < input_num; ++n) {
int offset = input_blob->offset(n);
caffe_sub(data_mean_.count(), input_data + offset,
data_mean_.cpu_data(), input_data + offset);
}
}
if (has_mean_values) {
CHECK(mean_values_.size() == 1 || mean_values_.size() == input_channels) <<
"Specify either 1 mean_value or as many as channels: " << input_channels;
if (mean_values_.size() == 1) {
caffe_add_scalar(input_blob->count(), -(mean_values_[0]), input_data);
} else {
for (int n = 0; n < input_num; ++n) {
for (int c = 0; c < input_channels; ++c) {
int offset = input_blob->offset(n, c);
caffe_add_scalar(input_height * input_width, -(mean_values_[c]),
input_data + offset);
}
}
}
}
Dtype* transformed_data = transformed_blob->mutable_cpu_data();
for (int n = 0; n < input_num; ++n) {
int top_index_n = n * channels;
int data_index_n = n * channels;
for (int c = 0; c < channels; ++c) {
int top_index_c = (top_index_n + c) * height;
int data_index_c = (data_index_n + c) * input_height + h_off;
for (int h = 0; h < height; ++h) {
int top_index_h = (top_index_c + h) * width;
int data_index_h = (data_index_c + h) * input_width + w_off;
if (do_mirror) {
int top_index_w = top_index_h + width - 1;
for (int w = 0; w < width; ++w) {
transformed_data[top_index_w-w] = input_data[data_index_h + w];
}
} else {
for (int w = 0; w < width; ++w) {
transformed_data[top_index_h + w] = input_data[data_index_h + w];
}
}
}
}
}
if (scale != Dtype(1)) {
DLOG(INFO) << "Scale: " << scale;
caffe_scal(size, scale, transformed_data);
}
}
//[0-*)
int zs_ut_s::Rand(int end)
{
return Rand(0, end);
}
void LootMgr::PushLoot(StoreLootList* list, Loot* loot, uint32 type)
{
uint32 i;
uint32 count;
if(type >= NUM_LOOT_TYPES)
return;
for(uint32 x = 0; x < list->count; x++)
{
if(list->items[x].item.itemproto) // this check is needed until loot DB is fixed
{
float chance = 0.0f;
switch(type)
{
case LOOT_NORMAL10:
chance = list->items[x].chance;
break;
case LOOT_NORMAL25:
chance = list->items[x].chance2;
break;
case LOOT_HEROIC10:
chance = list->items[x].chance3;
break;
case LOOT_HEROIC25:
chance = list->items[x].chance4;
break;
}
// drop chance cannot be larger than 100% or smaller than 0%
if(chance <= 0.0f || chance > 100.0f)
continue;
ItemPrototype* itemproto = list->items[x].item.itemproto;
if(Rand(chance * sWorld.getRate(RATE_DROP0 + itemproto->Quality))) //|| itemproto->Class == ITEM_CLASS_QUEST)
{
if(list->items[x].mincount == list->items[x].maxcount)
count = list->items[x].maxcount;
else
count = RandomUInt(list->items[x].maxcount - list->items[x].mincount) + list->items[x].mincount;
for(i = 0; i < loot->items.size(); ++i)
{
//itemid rand match a already placed item, if item is stackable and unique(stack), increment it, otherwise skips
if((loot->items[i].item.itemproto == list->items[x].item.itemproto) && itemproto->MaxCount && ((loot->items[i].iItemsCount + count) < itemproto->MaxCount))
{
if(itemproto->Unique && ((loot->items[i].iItemsCount + count) < itemproto->Unique))
{
loot->items[i].iItemsCount += count;
break;
}
else if(!itemproto->Unique)
{
loot->items[i].iItemsCount += count;
break;
}
}
}
if(i != loot->items.size())
continue;
__LootItem itm;
itm.item = list->items[x].item;
itm.iItemsCount = count;
itm.roll = NULL;
itm.passed = false;
itm.ffa_loot = list->items[x].ffa_loot;
itm.has_looted.clear();
if(itemproto->Quality > 1 && itemproto->ContainerSlots == 0)
{
itm.iRandomProperty = GetRandomProperties(itemproto);
itm.iRandomSuffix = GetRandomSuffix(itemproto);
}
else
{
// save some calls :P
itm.iRandomProperty = NULL;
itm.iRandomSuffix = NULL;
}
loot->items.push_back(itm);
}
}
}
if(loot->items.size() > 16)
{
std::vector<__LootItem>::iterator item_to_remove;
std::vector<__LootItem>::iterator itr;
uint32 item_quality;
bool quest_item;
while(loot->items.size() > 16)
{
item_to_remove = loot->items.begin();
item_quality = 0;
quest_item = false;
for(itr = loot->items.begin(); itr != loot->items.end(); ++itr)
{
item_quality = (*itr).item.itemproto->Quality;
quest_item = (*itr).item.itemproto->Class == ITEM_CLASS_QUEST;
if((*item_to_remove).item.itemproto->Quality > item_quality && !quest_item)
{
item_to_remove = itr;
}
}
loot->items.erase(item_to_remove);
}
}
}
/**
* @brief Generates a random integer from Uniform({0, 1, ..., n-1}).
*
* @param n
* The upperbound (exclusive) value of the random number.
* @return
* A uniformly random integer value from ({0, 1, ..., n-1}).
*/
unsigned int Rand(int n) const {
CHECK_GT(n, 0);
return Rand() % n;
}
void DataTransformer<Dtype>::TransformImgAndSeg(const std::vector<cv::Mat>& cv_img_seg,
Blob<Dtype>* transformed_data_blob, Blob<Dtype>* transformed_label_blob, const int ignore_label) {
CHECK(cv_img_seg.size() == 2) << "Input must contain image and seg.";
const int img_channels = cv_img_seg[0].channels();
// height and width may change due to pad for cropping
int img_height = cv_img_seg[0].rows;
int img_width = cv_img_seg[0].cols;
const int seg_channels = cv_img_seg[1].channels();
int seg_height = cv_img_seg[1].rows;
int seg_width = cv_img_seg[1].cols;
const int data_channels = transformed_data_blob->channels();
const int data_height = transformed_data_blob->height();
const int data_width = transformed_data_blob->width();
const int label_channels = transformed_label_blob->channels();
const int label_height = transformed_label_blob->height();
const int label_width = transformed_label_blob->width();
CHECK_EQ(seg_channels, 1);
CHECK_EQ(img_channels, data_channels);
CHECK_EQ(img_height, seg_height);
CHECK_EQ(img_width, seg_width);
CHECK_EQ(label_channels, 1);
CHECK_EQ(data_height, label_height);
CHECK_EQ(data_width, label_width);
CHECK(cv_img_seg[0].depth() == CV_8U) << "Image data type must be unsigned byte";
CHECK(cv_img_seg[1].depth() == CV_8U) << "Seg data type must be unsigned byte";
const int crop_size = param_.crop_size();
const Dtype scale = param_.scale();
const bool do_mirror = param_.mirror() && Rand(2);
const bool has_mean_file = param_.has_mean_file();
const bool has_mean_values = mean_values_.size() > 0;
CHECK_GT(img_channels, 0);
Dtype* mean = NULL;
if (has_mean_file) {
CHECK_EQ(img_channels, data_mean_.channels());
CHECK_EQ(img_height, data_mean_.height());
CHECK_EQ(img_width, data_mean_.width());
mean = data_mean_.mutable_cpu_data();
}
if (has_mean_values) {
CHECK(mean_values_.size() == 1 || mean_values_.size() == img_channels) <<
"Specify either 1 mean_value or as many as channels: " << img_channels;
if (img_channels > 1 && mean_values_.size() == 1) {
// Replicate the mean_value for simplicity
for (int c = 1; c < img_channels; ++c) {
mean_values_.push_back(mean_values_[0]);
}
}
}
int h_off = 0;
int w_off = 0;
cv::Mat cv_cropped_img = cv_img_seg[0];
cv::Mat cv_cropped_seg = cv_img_seg[1];
// transform to double, since we will pad mean pixel values
cv_cropped_img.convertTo(cv_cropped_img, CV_64F);
// Check if we need to pad img to fit for crop_size
// copymakeborder
int pad_height = std::max(crop_size - img_height, 0);
int pad_width = std::max(crop_size - img_width, 0);
if (pad_height > 0 || pad_width > 0) {
cv::copyMakeBorder(cv_cropped_img, cv_cropped_img, 0, pad_height,
0, pad_width, cv::BORDER_CONSTANT,
cv::Scalar(mean_values_[0], mean_values_[1], mean_values_[2]));
cv::copyMakeBorder(cv_cropped_seg, cv_cropped_seg, 0, pad_height,
0, pad_width, cv::BORDER_CONSTANT,
cv::Scalar(ignore_label));
// update height/width
img_height = cv_cropped_img.rows;
img_width = cv_cropped_img.cols;
seg_height = cv_cropped_seg.rows;
seg_width = cv_cropped_seg.cols;
}
// crop img/seg
if (crop_size) {
CHECK_EQ(crop_size, data_height);
CHECK_EQ(crop_size, data_width);
// We only do random crop when we do training.
if (phase_ == Caffe::TRAIN) {
h_off = Rand(img_height - crop_size + 1);
w_off = Rand(img_width - crop_size + 1);
} else {
// CHECK: use middle crop
h_off = (img_height - crop_size) / 2;
w_off = (img_width - crop_size) / 2;
}
cv::Rect roi(w_off, h_off, crop_size, crop_size);
cv_cropped_img = cv_cropped_img(roi);
cv_cropped_seg = cv_cropped_seg(roi);
}
CHECK(cv_cropped_img.data);
CHECK(cv_cropped_seg.data);
Dtype* transformed_data = transformed_data_blob->mutable_cpu_data();
Dtype* transformed_label = transformed_label_blob->mutable_cpu_data();
int top_index;
const double* data_ptr;
const uchar* label_ptr;
for (int h = 0; h < data_height; ++h) {
data_ptr = cv_cropped_img.ptr<double>(h);
label_ptr = cv_cropped_seg.ptr<uchar>(h);
int data_index = 0;
int label_index = 0;
for (int w = 0; w < data_width; ++w) {
// for image
for (int c = 0; c < img_channels; ++c) {
if (do_mirror) {
top_index = (c * data_height + h) * data_width + (data_width - 1 - w);
} else {
top_index = (c * data_height + h) * data_width + w;
}
Dtype pixel = static_cast<Dtype>(data_ptr[data_index++]);
if (has_mean_file) {
int mean_index = (c * img_height + h_off + h) * img_width + w_off + w;
transformed_data[top_index] =
(pixel - mean[mean_index]) * scale;
} else {
if (has_mean_values) {
transformed_data[top_index] =
(pixel - mean_values_[c]) * scale;
} else {
transformed_data[top_index] = pixel * scale;
}
}
}
// for segmentation
if (do_mirror) {
top_index = h * data_width + data_width - 1 - w;
} else {
top_index = h * data_width + w;
}
Dtype pixel = static_cast<Dtype>(label_ptr[label_index++]);
transformed_label[top_index] = pixel;
}
}
}
float Rand(float _min, float _max)
{
return _min + Rand() * (_max - _min);
}
void chromosome::mutSelection(double probMut) {
int ind, num;
chromosome app(*this);
int realNumR;
bool trovato=true;
/* if (numRul>minRule && Rand()<0.1)
{ ind = Randint(0, numRul - 1);
app.vettR[ind].index=dimMatWM;
app.ordinaIndex(); //ordina gli indici e calcola il numRul
app.faiMatdaVec();
app.deleteDup();
realNumR=app.numRul;
if (realNumR >= minRule)
{ if (!CLASSIFICATION)
copyChrom(app);
else
if (controllaPresenzaClassi((int**)app.matR,app.numRul))
copyChrom(app);
}
}*/
if (dimMatWM > maxRule && Rand() < 0.1) //modifico o aggiungo una regola
{
ind = Randint(0, maxRule - 1); //elemento del vettore da modificare
while(trovato)
{ num = Randint(0, dimMatWM - 1); //seleziono una regola che non e' gia' presente
trovato=false;
for (int i=0;i<numRul;i++)
if (app.vettR[i].index==num)
{ trovato=true;
break;
}
}
app.vettR[ind].index = num;
/*if (app.vettR[ind].index==dimMatWM) //sto aggiungendo
{ */
for (int i=0;i<numVar-1;i++)
if(matWM[num]!=0)
app.vettR[ind].vectAnt[i]=true;
else
app.vettR[ind].vectAnt[i]=false;
//}
app.ordinaIndex(); //ordina gli indici e calcola il numRul
app.faiMatdaVec();
app.deleteDup();
realNumR=app.numRul;
if (realNumR >= minRule)
{ if (!CLASSIFICATION)
copyChrom(app);
else
if (controllaPresenzaClassi((int**)app.matR,app.numRul))
copyChrom(app);
}
}
int conta = 0;
if (SIZE_POP_PR && Rand() < 0.7)
{ ind = Randint(0, app.numRul - 1);
for (int i = 0; i < numVar-1; i++)
if (matWM[ind][i]!=0 && Rand() < (double) 2 / (numVar-1))
app.vettR[ind].vectAnt[i] = !app.vettR[ind].vectAnt[i];
for (int i = 0; i < numVar-1; i++)
if (app.vettR[ind].vectAnt[i] != 0)
conta++;
}
if (conta >= minTerms)
{ app.faiMatdaVec();
app.deleteDup();
realNumR=app.numRul;
if (realNumR >= minRule)
{ if (!CLASSIFICATION)
copyChrom(app);
else
if (controllaPresenzaClassi((int**)app.matR,app.numRul))
copyChrom(app);
}
}
}
double terra::PerlinNoise::GetSmooth(int X){
// Do some averaging of values
double Center = Rand(X);
double Sides = (Rand(X-1)+Rand(X+1))/2.;
return (2.*Center+Sides)/3.;
}
int main(int argc, char** argv) {
srand (time(NULL));
typedef Givaro::Modular<double> Field;
Givaro::Integer q = 131071;
size_t iter = 10;
Argument as[] = {
{ 'q', "-q Q", "Set the field characteristic (-1 for random).", TYPE_INTEGER , &q },
{ 'i', "-i R", "Set number of repetitions.", TYPE_INT , &iter },
END_OF_ARGUMENTS
};
FFLAS::parseArguments(argc,argv,as);
Field F(q);
Field::RandIter Rand(F);
FFLAS::FFLAS_TRANSPOSE ta,tb;
size_t pass = 0;
for (size_t i=0; i<iter; ++i) {
size_t m = rand() % 1000 + 1;
size_t n = rand() % 1000 + 1;
size_t k = rand() % 1000 + 1;
std::cout << "m= " << m << " n= " << n << " k= " << k << " ";
typename Field::Element alpha,beta;
F.init(alpha); Rand.random(alpha);
F.init(beta); Rand.random(beta);
ta = rand()%2 ? FFLAS::FflasNoTrans : FFLAS::FflasTrans;
tb = rand()%2 ? FFLAS::FflasNoTrans : FFLAS::FflasTrans;
std::cout << "m= " << m << " n= " << n << " k= " << k
<<" ta = ";
if (ta==FFLAS::FflasNoTrans) std::cout<<"NoTrans";
else std::cout<<"Trans";
std::cout<< " tb = ";
if (tb==FFLAS::FflasNoTrans) std::cout<<"NoTrans";
else std::cout<<"Trans";
std::cout<<" : ";
size_t lda = ta == FFLAS::FflasNoTrans ? k : m,
ldb = tb == FFLAS::FflasNoTrans ? n : k,
ldc = n;
Field::Element_ptr A = FFLAS::fflas_new(F,m,k);
Field::Element_ptr B = FFLAS::fflas_new(F,k,n);
Field::Element_ptr C = FFLAS::fflas_new(F,m,n);
FFLAS::frand(F,Rand, m,k,A,k);
FFLAS::frand(F,Rand, k,n,B,n);
FFLAS::frand(F,Rand, m,n,C,n);
FFLAS::Checker_fgemm<Field> checker(F,m,n,k,beta,C,ldc);
FFLAS::fgemm(F,ta,tb,m,n,k,alpha,A,lda,B,ldb,beta,C,ldc);
try {
checker.check(ta,tb,alpha,A,lda,B,ldb,C);
std::cout << "PASSED\n";
pass++;
} catch (FailureFgemmCheck &e) {
std::cout << "FAILED\n";
FFLAS::fflas_delete(A,B,C);
return -1;
}
FFLAS::fflas_delete(A,B,C);
}
std::cout << pass << "/" << iter << " tests were successful.\n";
return 0;
}
void AiAgentHealSupport::Update(uint32 p_time)
{
_UpdateTimer(p_time);
_UpdateMovement(p_time);
if( !m_PetOwner )
return; //oh noez, our master has abandoned us ! Where is te luv ?
//we used this spell to create healbot. To avoid logout / login recreate we need to remove aura
// lol, this will never work :(
if( !m_Unit->isAlive() )
m_PetOwner->RemoveAura( 36765 );
if( m_Unit->GetMapMgr() != m_PetOwner->GetMapMgr() )
{
m_PetOwner->RemoveAura( 36765 );
m_Unit->EventSummonPetExpire();
}
if( m_Unit->isCasting() )
return; // we are already supporting someone ...get back later
//we should be at same level at owner so we profit of fighting formulas same as owner
if( m_Unit->GetUInt32Value( UNIT_FIELD_LEVEL ) != m_PetOwner->GetUInt32Value( UNIT_FIELD_LEVEL ) )
{
m_Unit->SetUInt32Value( UNIT_FIELD_LEVEL, m_PetOwner->GetUInt32Value( UNIT_FIELD_LEVEL ) );
DifficultyLevel = m_PetOwner->GetUInt32Value( UNIT_FIELD_LEVEL ) / 80.0f;
//printf("difficulty changed to %f \n",DifficultyLevel);
//scale health and mana.when we level we max out our stats
m_Unit->SetUInt32Value( UNIT_FIELD_MAXHEALTH , (uint32)(m_Unit->GetUInt32Value( UNIT_FIELD_BASE_HEALTH ) * ( 1 + DifficultyLevel ) * CREATURE_STATS_SCALE_WITH_DIFFICULTY) );
m_Unit->SetUInt32Value( UNIT_FIELD_MAXPOWER1 , (uint32)(m_Unit->GetUInt32Value( UNIT_FIELD_BASE_MANA ) * ( 1 + DifficultyLevel ) * CREATURE_STATS_SCALE_WITH_DIFFICULTY) );
m_Unit->SetUInt32Value( UNIT_FIELD_HEALTH , (uint32)(m_Unit->GetUInt32Value( UNIT_FIELD_HEALTH ) * ( 1 + DifficultyLevel ) * CREATURE_STATS_SCALE_WITH_DIFFICULTY) );
m_Unit->SetUInt32Value( UNIT_FIELD_POWER1 , (uint32)(m_Unit->GetUInt32Value( UNIT_FIELD_POWER1 ) * ( 1 + DifficultyLevel ) * CREATURE_STATS_SCALE_WITH_DIFFICULTY) );
}
//if owner fights a long combat then we he desrvers to get lasy at the end ?
if( m_PetOwner->CombatStatus.IsInCombat() )
CombatDifficultyLevel += DIFFICULTY_UPDATE_SPEED;
else CombatDifficultyLevel = 0;
if( CombatDifficultyLevel > 1 )
CombatDifficultyLevel = 1;
uint32 Time_Now = getMSTime();
std::list<healagentspell*>::iterator itr;
SpellCastTargets targets( m_PetOwner->GetGUID() );
healagentspell *m_castingSpell = NULL;
Unit *SpellTarget = m_PetOwner;
//poor thing died. Res him.
//will never work
if( !m_PetOwner->isAlive() && CheckCanCast( revive_spell.sp, SpellTarget ) )
{
m_castingSpell = &revive_spell;
//printf("master died, we are going to resurect him\n");
}
//if we are injusred we should try to survive it
if ( m_castingSpell== NULL && m_Unit->GetUInt32Value( UNIT_FIELD_HEALTH ) < m_Unit->GetUInt32Value( UNIT_FIELD_MAXHEALTH ) )
{
//printf("we are injured, diff is %u \n",m_Unit->GetUInt32Value( UNIT_FIELD_MAXHEALTH ) - m_Unit->GetUInt32Value( UNIT_FIELD_HEALTH ));
if( !Protect_self() ) //first we try to escape combat
{
m_castingSpell = PickSpellFromList( &m_healspells, m_Unit );
SpellTarget = m_Unit;
}
else
{
m_castingSpell = &m_defend_self;
SpellTarget = m_Unit;
}
}
//select an augment spell if we have nothing better to do
if( m_castingSpell== NULL && m_PetOwner->GetUInt32Value( UNIT_FIELD_HEALTH ) == m_PetOwner->GetUInt32Value( UNIT_FIELD_MAXHEALTH ) )
{
//printf("master is ok, we can try augment someone\n");
m_castingSpell = PickSpellFromList( &m_AugmentSelf, m_Unit );
//try augment owner ?
if( !m_castingSpell )
{
m_castingSpell = PickSpellFromList( &m_AugmentTarget, m_PetOwner );
SpellTarget = m_Unit;
}
}
//master is injured, this should be most common case
if( m_castingSpell==NULL && m_PetOwner->GetUInt32Value( UNIT_FIELD_HEALTH ) < m_PetOwner->GetUInt32Value( UNIT_FIELD_MAXHEALTH ) )
{
//printf("master is injured, will try to heal him\n");
m_castingSpell = PickSpellFromList( &m_healspells , m_PetOwner);
SpellTarget = m_PetOwner;
}
if( m_castingSpell )
{
//printf("we have a spell to cast\n");
SpellCastTime *sd = dbcSpellCastTime.LookupEntry( m_castingSpell->sp->CastingTimeIndex );
//do not stop for instant casts
if(GetCastTime(sd) != 0)
{
StopMovement(0);
//printf("spell is not instant so we are going to stop movement \n");
}
float distance = m_Unit->GetDistanceSq( SpellTarget );
if( distance <= m_castingSpell->sp->base_range_or_radius_sqr || m_castingSpell->sp->base_range_or_radius_sqr == 0 )
{
//printf("we are in range and going to cast spell \n");
m_AIState = STATE_CASTING;
Spell *nspell = SpellPool.PooledNew();
nspell->Init(m_Unit, m_castingSpell->sp, false, NULL);
#ifdef SPELL_EFF_PCT_SCALE_WITH_DIFFICULTY
if( m_castingSpell->max_scale )
{
nspell->forced_basepoints[ 0 ] = (uint32)( m_castingSpell->max_scale * ( DifficultyLevel + CombatDifficultyLevel) );
if( nspell->forced_basepoints[ 0 ] > m_castingSpell->max_scale * 2)
nspell->forced_basepoints[ 0 ] = m_castingSpell->max_scale * 2;
}
#endif
targets.m_unitTarget = SpellTarget->GetGUID();
nspell->prepare( &targets );
CastSpell( m_Unit, m_castingSpell->sp, targets );
SetSpellDuration( m_castingSpell );
//mana regen is to big, he can cast forever, double mana usage maybe regulates this
m_Unit->ModSignedInt32Value( UNIT_FIELD_POWER1, -m_castingSpell->sp->manaCost );
}
else // Target out of Range -> Run to it
{
//printf("we are going to move closer \n");
m_moveRun = true;
_CalcDestinationAndMove( SpellTarget, sqrt( m_castingSpell->sp->base_range_or_radius_sqr ) );
}
}
// check if pets regenrate mana, If not then we should implement that too
//if owner is mounted then we mount too. Speed is not set though
if( m_PetOwner->GetUInt32Value( UNIT_FIELD_MOUNTDISPLAYID ) && m_Unit->GetUInt32Value( UNIT_FIELD_MOUNTDISPLAYID ) == 0 )
{
if( Owner_side == OWNER_SIDE_ALIANCE )
m_Unit->SetUInt32Value( UNIT_FIELD_MOUNTDISPLAYID, HELPER_MOUNT_A_DISPLAY );
else
m_Unit->SetUInt32Value( UNIT_FIELD_MOUNTDISPLAYID, OWNER_SIDE_HORDE );
m_moveSprint = true;
}
else if( m_PetOwner->GetUInt32Value( UNIT_FIELD_MOUNTDISPLAYID ) == 0 && m_Unit->GetUInt32Value( UNIT_FIELD_MOUNTDISPLAYID ) != 0 )
{
m_Unit->SetUInt32Value( UNIT_FIELD_MOUNTDISPLAYID, 0 );
m_moveSprint = false;
}
//for fun : mimic master standstate. Note that this might give strange results
if( m_PetOwner->GetStandState() != m_Unit->GetStandState() )
m_Unit->SetStandState( m_PetOwner->GetStandState() );
if( m_castingSpell == NULL )
{
if( First_noaction_stamp == 0 )
First_noaction_stamp = Time_Now;
float dist = m_Unit->CalcDistance( m_PetOwner );
//printf("we are far from owner, we should move closer , dist %f from %f \n",dist,(FollowDistance*FollowDistance));
if ( dist > FollowDistance ) //if out of range
{
m_moveRun = true;
if(dist > 20.0f)
m_moveSprint = true;
float delta_x = UnitToFollow->GetPositionX();
float delta_y = UnitToFollow->GetPositionY();
float d = 3;
MoveTo(delta_x+(d*(cosf(m_fallowAngle+m_PetOwner->GetOrientation()))),
delta_y+(d*(sinf(m_fallowAngle+m_PetOwner->GetOrientation()))),
m_PetOwner->GetPositionZ(),m_PetOwner->GetOrientation());
}
}
else if(m_castingSpell != NULL )
First_noaction_stamp = 0;
//if( First_noaction_stamp )printf("ms to say something %u and ms for say cooldown %u\n",First_noaction_stamp + BOREDOM_TIMER_TO_START_TRIGGERING - Time_Now,Boredom_cooldown - Time_Now );
if(
First_noaction_stamp
&& First_noaction_stamp + BOREDOM_TIMER_TO_START_TRIGGERING < Time_Now
&& Boredom_cooldown < Time_Now
)
{
//some chance to say something
if( Rand( 50 ) )
m_Unit->SendChatMessage(CHAT_MSG_MONSTER_SAY, LANG_UNIVERSAL, bored_texts[ RandomUInt( BOREDOM_TEXTCOUNT ) ]);
else
m_Unit->SetUInt32Value ( UNIT_NPC_EMOTESTATE, bored_emotes[ RandomUInt( BOREDOM_EMOTECOUNT ) ] );
Boredom_cooldown = Time_Now + BOREDOM_TRIGGER_INTERVAL;
}
}
int NEURAL_NETWORK::FlipCoin(void) {
return( Rand(0.0,1.0) > 0.5 );
}
f32 MyRandom::RandFloat()
{
return Rand() / f32(RAND_MAX);
}
virtual void step(float dtime)
{
{
static float counter1 = 0;
counter1 -= dtime;
if(counter1 < 0.0)
{
counter1 = 0.1*Rand(1, 40);
keydown.toggle(getKeySetting("keymap_jump"));
}
}
{
static float counter1 = 0;
counter1 -= dtime;
if(counter1 < 0.0)
{
counter1 = 0.1*Rand(1, 40);
keydown.toggle(getKeySetting("keymap_special1"));
}
}
{
static float counter1 = 0;
counter1 -= dtime;
if(counter1 < 0.0)
{
counter1 = 0.1*Rand(1, 40);
keydown.toggle(getKeySetting("keymap_forward"));
}
}
{
static float counter1 = 0;
counter1 -= dtime;
if(counter1 < 0.0)
{
counter1 = 0.1*Rand(1, 40);
keydown.toggle(getKeySetting("keymap_left"));
}
}
{
static float counter1 = 0;
counter1 -= dtime;
if(counter1 < 0.0)
{
counter1 = 0.1*Rand(1, 20);
mousespeed = v2s32(Rand(-20,20), Rand(-15,20));
}
}
{
static float counter1 = 0;
counter1 -= dtime;
if(counter1 < 0.0)
{
counter1 = 0.1*Rand(1, 30);
leftdown = !leftdown;
if(leftdown)
leftclicked = true;
if(!leftdown)
leftreleased = true;
}
}
{
static float counter1 = 0;
counter1 -= dtime;
if(counter1 < 0.0)
{
counter1 = 0.1*Rand(1, 15);
rightdown = !rightdown;
if(rightdown)
rightclicked = true;
if(!rightdown)
rightreleased = true;
}
}
mousepos += mousespeed;
}
float Random::Range(float start, float end) {
return static_cast<float>(Rand()&0x7fffffff) / ((0x7fffffff)/(end-start)) + start;
}
static void SelectNShapes (
vec_SHAPE &Shapes, // io
vec_string &Tags, // io: also shuffled, in step with Shapes
int nWantedShapes, // in: 0 means return all shapes
int nSeed=0) // in: 0 means no random selection; if any other
// val select randomly with rand seed=nSeed
{
unsigned nShapes = Tags.size();
if (nWantedShapes == 0)
nWantedShapes = nShapes;
nWantedShapes = MIN((unsigned)nWantedShapes, nShapes);
if (nSeed)
{
// generate a shuffled set of indices in iShuffledShapes
vec_int iShuffledShapes(nShapes);
unsigned iShape;
for (iShape = 0; iShape < nShapes; iShape++)
iShuffledShapes[iShape] = iShape;
SeedRand(nSeed);
// We use our own random shuffle here because different compilers
// give different results which messes up regression testing.
// (I think only Visual C 6.0 is incompatible with everyone else?)
//
// Following code is equivalent to
// random_shuffle(iShuffledShapes.begin(), iShuffledShapes.end(),
// pointer_to_unary_function<int,int>(Rand));
vec_int::iterator pNext = iShuffledShapes.begin();
for (int i = 2; ++pNext != iShuffledShapes.end(); ++i)
iter_swap(pNext, iShuffledShapes.begin() + Rand(i));
iShuffledShapes.resize(nWantedShapes);
// sort the selected indices so we can do an in-place replacement in Shapes
sort(iShuffledShapes.begin(), iShuffledShapes.end());
// keep the first nWantedShapes in iShuffledShapes
for (iShape = 0; iShape < unsigned(nWantedShapes); iShape++)
{
unsigned iOldShape = iShuffledShapes[iShape];
if (iShape > 0 && Shapes[0].nrows() != Shapes[iOldShape].nrows())
{
static bool fIssuedWarning;
if (!fIssuedWarning)
{
fIssuedWarning = true;
WarnWithNewLine("different sized shapes (%s has %d rows, %s has %d rows)\n",
sGetBasenameFromTag(Tags[0].c_str()), Shapes[0].nrows(),
sGetBasenameFromTag(Tags[iOldShape].c_str()), Shapes[iOldShape].nrows());
}
}
Shapes[iShape].assign(Shapes[iOldShape]);
Tags[iShape] = Tags[iOldShape];
}
}
Shapes.resize(nWantedShapes);
Tags.resize(nWantedShapes);
}
int32 Random::Int32() {
return Rand();
}
void PGSRF(
GeomSolid * geounit,
GrGeomSolid *gr_geounit,
Vector * field,
RFCondData * cdata)
{
/*-----------------*
* Local variables *
*-----------------*/
PFModule *this_module = ThisPFModule;
PublicXtra *public_xtra = (PublicXtra*)PFModulePublicXtra(this_module);
InstanceXtra *instance_xtra = (InstanceXtra*)PFModuleInstanceXtra(this_module);
/* Input parameters (see PGSRFNewPublicXtra() below) */
double lambdaX = (public_xtra->lambdaX);
double lambdaY = (public_xtra->lambdaY);
double lambdaZ = (public_xtra->lambdaZ);
double mean = (public_xtra->mean);
double sigma = (public_xtra->sigma);
int dist_type = (public_xtra->dist_type);
double low_cutoff = (public_xtra->low_cutoff);
double high_cutoff = (public_xtra->high_cutoff);
int max_search_rad = (public_xtra->max_search_rad);
int max_npts = (public_xtra->max_npts);
int max_cpts = (public_xtra->max_cpts);
Vector *tmpRF = NULL;
/* Conditioning data */
int nc = (cdata->nc);
double *x = (cdata->x);
double *y = (cdata->y);
double *z = (cdata->z);
double *v = (cdata->v);
/* Grid parameters */
Grid *grid = (instance_xtra->grid);
Subgrid *subgrid;
Subvector *sub_field;
Subvector *sub_tmpRF;
int NX, NY, NZ;
/* Subgrid parameters */
int nx, ny, nz;
double dx, dy, dz;
int nx_v, ny_v, nz_v;
int nx_v2, ny_v2, nz_v2;
int nxG, nyG, nzG;
/* Counters, indices, flags */
int gridloop;
int i, j, k, n, m;
int ii, jj, kk;
int i2, j2, k2;
int imin, jmin, kmin;
int rpx, rpy, rpz;
int npts;
int index1, index2, index3;
/* Spatial variables */
double *fieldp;
double *tmpRFp;
int iLx, iLy, iLz; /* Correlation length in terms of grid points */
int iLxp1, iLyp1, iLzp1; /* One more than each of the above */
int nLx, nLy, nLz; /* Size of correlation neighborhood in grid pts. */
int iLxyz; /* iLxyz = iLx*iLy*iLz */
int nLxyz; /* nLxyz = nLx*nLy*nLz */
int ix, iy, iz;
int ref;
int ix2, iy2, iz2;
int i_search, j_search, k_search;
int ci_search, cj_search, ck_search;
double X0, Y0, Z0;
/* Variables used in kriging algorithm */
double cmean, csigma; /* Conditional mean and std. dev. from kriging */
double A;
double *A_sub; /* Sub-covariance matrix for external cond pts */
double *A11; /* Submatrix; note that A11 is 1-dim */
double **A12, **A21, **A22;/* Submatrices for external conditioning data */
double **M; /* Used as a temporary matrix */
double *b; /* Covariance vector for conditioning points */
double *b_tmp, *b2;
double *w, *w_tmp; /* Solution vector to Aw=b */
int *ixx, *iyy, *izz;
double *value;
int di, dj, dk;
double uni, gau;
double ***cov;
int ierr;
/* Conditioning data variables */
int cpts; /* N cond pts for a single simulated node */
double *cval; /* Values for cond data for single node */
/* Communications */
VectorUpdateCommHandle *handle;
int update_mode;
/* Miscellaneous variables */
int **rand_path;
char ***marker;
int p, r, modulus;
double a1, a2, a3;
double cx, cy, cz;
double sum;
// FIXME Shouldn't we get this from numeric_limits?
double Tiny = 1.0e-12;
(void)geounit;
/*-----------------------------------------------------------------------
* Allocate temp vectors
*-----------------------------------------------------------------------*/
tmpRF = NewVectorType(instance_xtra->grid, 1, max_search_rad, vector_cell_centered);
/*-----------------------------------------------------------------------
* Start sequential Gaussian simulator algorithm
*-----------------------------------------------------------------------*/
/* Begin timing */
BeginTiming(public_xtra->time_index);
/* initialize random number generators */
SeedRand(public_xtra->seed);
/* For now, we will assume that all subgrids have the same uniform spacing */
subgrid = GridSubgrid(grid, 0);
dx = SubgridDX(subgrid);
dy = SubgridDY(subgrid);
dz = SubgridDZ(subgrid);
/* Size of search neighborhood through which random path must be defined */
iLx = (int)(lambdaX / dx);
iLy = (int)(lambdaY / dy);
iLz = (int)(lambdaZ / dz);
/* For computational efficiency, we'll limit the
* size of the search neighborhood. */
if (iLx > max_search_rad)
iLx = max_search_rad;
if (iLy > max_search_rad)
iLy = max_search_rad;
if (iLz > max_search_rad)
iLz = max_search_rad;
iLxp1 = iLx + 1;
iLyp1 = iLy + 1;
iLzp1 = iLz + 1;
iLxyz = iLxp1 * iLyp1 * iLzp1;
/* Define the size of a correlation neighborhood */
nLx = 2 * iLx + 1;
nLy = 2 * iLy + 1;
nLz = 2 * iLz + 1;
nLxyz = nLx * nLy * nLz;
/*------------------------
* Define a random path through the points in this subgrid.
* The random path generation procedure of Srivastava and
* Gomez has been adopted in this subroutine. A linear
* congruential generator of the form: r(i) = 5*r(i-1)+1 mod(2**n)
* has a cycle length of 2**n. By choosing the smallest power of
* 2 that is still larger than the total number of points to be
* simulated, the method ensures that all indices will be
* generated once and only once.
*------------------------*/
rand_path = talloc(int*, iLxyz);
for (i = 0; i < iLxyz; i++)
rand_path[i] = talloc(int, 3);
modulus = 2;
while (modulus < iLxyz + 1)
modulus *= 2;
/* Compute a random starting node */
p = (int)Rand();
r = 1 + p * (iLxyz - 1);
k = (r - 1) / (iLxp1 * iLyp1);
j = (r - 1 - iLxp1 * iLyp1 * k) / iLxp1;
i = (r - 1) - (k * iLyp1 + j) * iLxp1;
rand_path[0][2] = k;
rand_path[0][1] = j;
rand_path[0][0] = i;
/* Determine the next nodes */
for (n = 1; n < iLxyz; n++)
{
r = (5 * r + 1) % modulus;
while ((r < 1) || (r > iLxyz))
r = (5 * r + 1) % modulus;
k = ((r - 1) / (iLxp1 * iLyp1));
j = (((r - 1) - iLxp1 * iLyp1 * k) / iLxp1);
i = (r - 1) - (k * iLyp1 + j) * iLxp1;
rand_path[n][0] = i;
rand_path[n][1] = j;
rand_path[n][2] = k;
}
/*-----------------------------------------------------------------------
* Compute correlation lookup table
*-----------------------------------------------------------------------*/
/* First compute a covariance lookup table */
cov = talloc(double**, nLx);
for (i = 0; i < nLx; i++)
{
cov[i] = talloc(double*, nLy);
for (j = 0; j < nLy; j++)
cov[i][j] = ctalloc(double, nLz);
}
/* Note that in the construction of the covariance matrix
* the max_search_rad is not used. Covariance depends upon
* the correlation lengths, lambdaX/Y/Z, and the grid spacing.
* The max_search_rad can be longer or shorter than the correlation
* lengths. The bigger the search radius, the more accurately
* the random field will match the correlation structure of the
* covariance function. But the run time will increase greatly
* as max_search_rad gets bigger because of the kriging matrix
* that must be solved (see below).
*/
cx = 0.0;
cy = 0.0;
cz = 0.0;
if (lambdaX != 0.0)
cx = dx * dx / (lambdaX * lambdaX);
if (lambdaY != 0.0)
cy = dy * dy / (lambdaY * lambdaY);
if (lambdaZ != 0.0)
cz = dz * dz / (lambdaZ * lambdaZ);
for (k = 0; k < nLz; k++)
for (j = 0; j < nLy; j++)
for (i = 0; i < nLx; i++)
{
a1 = i * i * cx;
a2 = j * j * cy;
a3 = k * k * cz;
cov[i][j][k] = exp(-sqrt(a1 + a2 + a3));
}
/* Allocate memory for variables that will be used in kriging */
A11 = ctalloc(double, nLxyz * nLxyz);
A_sub = ctalloc(double, nLxyz * nLxyz);
A12 = ctalloc(double*, nLxyz);
A21 = ctalloc(double*, nLxyz);
A22 = ctalloc(double*, nLxyz);
M = ctalloc(double*, nLxyz);
for (i = 0; i < nLxyz; i++)
{
A12[i] = ctalloc(double, nLxyz);
A21[i] = ctalloc(double, nLxyz);
A22[i] = ctalloc(double, nLxyz);
M[i] = ctalloc(double, nLxyz);
}
b = ctalloc(double, nLxyz);
b2 = ctalloc(double, nLxyz);
b_tmp = ctalloc(double, nLxyz);
w = ctalloc(double, nLxyz);
w_tmp = ctalloc(double, nLxyz);
value = ctalloc(double, nLxyz);
cval = ctalloc(double, nLxyz);
ixx = ctalloc(int, nLxyz);
iyy = ctalloc(int, nLxyz);
izz = ctalloc(int, nLxyz);
/* Allocate space for the "marker" used to keep track of which
* points in a representative correlation box have been simulated
* already.
*/
marker = talloc(char**, (3 * iLx + 1));
marker += iLx;
for (i = -iLx; i <= 2 * iLx; i++)
{
marker[i] = talloc(char*, (3 * iLy + 1));
marker[i] += iLy;
for (j = -iLy; j <= 2 * iLy; j++)
{
marker[i][j] = ctalloc(char, (3 * iLz + 1));
marker[i][j] += iLz;
for (k = -iLz; k <= 2 * iLz; k++)
marker[i][j][k] = 0;
}
}
/* Convert the cutoff values to a gaussian if they're lognormal on input */
if ((dist_type == 1) || (dist_type == 3))
{
if (low_cutoff <= 0.0)
{
low_cutoff = Tiny;
}
else
{
low_cutoff = (log(low_cutoff / mean)) / sigma;
}
if (high_cutoff <= 0.0)
{
high_cutoff = DBL_MAX;
}
else
{
high_cutoff = (log(high_cutoff / mean)) / sigma;
}
}
/*--------------------------------------------------------------------
* Start pGs algorithm
*--------------------------------------------------------------------*/
for (gridloop = 0; gridloop < GridNumSubgrids(grid); gridloop++)
{
subgrid = GridSubgrid(grid, gridloop);
sub_tmpRF = VectorSubvector(tmpRF, gridloop);
sub_field = VectorSubvector(field, gridloop);
tmpRFp = SubvectorData(sub_tmpRF);
fieldp = SubvectorData(sub_field);
X0 = RealSpaceX(0, SubgridRX(subgrid));
Y0 = RealSpaceY(0, SubgridRY(subgrid));
Z0 = RealSpaceZ(0, SubgridRZ(subgrid));
ix = SubgridIX(subgrid);
iy = SubgridIY(subgrid);
iz = SubgridIZ(subgrid);
nx = SubgridNX(subgrid);
ny = SubgridNY(subgrid);
nz = SubgridNZ(subgrid);
NX = ix + nx;
NY = iy + ny;
NZ = iz + nz;
/* RDF: assume resolution is the same in all 3 directions */
ref = SubgridRX(subgrid);
nx_v = SubvectorNX(sub_field);
ny_v = SubvectorNY(sub_field);
nz_v = SubvectorNZ(sub_field);
nx_v2 = SubvectorNX(sub_tmpRF);
ny_v2 = SubvectorNY(sub_tmpRF);
nz_v2 = SubvectorNZ(sub_tmpRF);
/* Initialize tmpRF vector */
GrGeomInLoop(i, j, k, gr_geounit, ref, ix, iy, iz, nx, ny, nz,
{
index2 = SubvectorEltIndex(sub_tmpRF, i, j, k);
tmpRFp[index2] = 0.0;
});
/* Convert conditioning data to N(0,1) distribution if
* it's assumed to be lognormal. Then copy it into tmpRFp */
if ((dist_type == 1) || (dist_type == 3))
{
for (n = 0; n < nc; n++)
{
i = (int)((x[n] - X0) / dx + 0.5);
j = (int)((y[n] - Y0) / dy + 0.5);
k = (int)((z[n] - Z0) / dz + 0.5);
if ((ix - max_search_rad <= i && i <= ix + nx + max_search_rad) &&
(iy - max_search_rad <= j && j <= iy + ny + max_search_rad) &&
(iz - max_search_rad <= k && k <= iz + nz + max_search_rad))
{
index2 = SubvectorEltIndex(sub_tmpRF, i, j, k);
if (v[n] <= 0.0)
tmpRFp[index2] = Tiny;
else
tmpRFp[index2] = (log(v[n] / mean)) / sigma;
}
}
}
/* Otherwise, shift data to N(0,1) distribution */
else
{
for (n = 0; n < nc; n++)
{
i = (int)((x[n] - X0) / dx + 0.5);
j = (int)((y[n] - Y0) / dy + 0.5);
k = (int)((z[n] - Z0) / dz + 0.5);
if ((ix - max_search_rad <= i && i <= ix + nx + max_search_rad) &&
(iy - max_search_rad <= j && j <= iy + ny + max_search_rad) &&
(iz - max_search_rad <= k && k <= iz + nz + max_search_rad))
{
index2 = SubvectorEltIndex(sub_tmpRF, i, j, k);
tmpRFp[index2] = (v[n] - mean) / sigma;
}
}
}
/* Set the search radii in each direction. If the maximum
* number of points in a neighborhood is exceeded, these limits
* will be reduced. */
i_search = iLx;
j_search = iLy;
k_search = iLz;
/* Compute values at all points using all templates */
for (n = 0; n < iLxyz; n++)
{
/* Update the ghost layer before proceeding */
if (n > 0)
{
/* First reset max_search_radius */
max_search_rad = i_search;
if (j_search > max_search_rad)
max_search_rad = j_search;
if (k_search > max_search_rad)
max_search_rad = k_search;
/* Reset the comm package based on the new max_search_radius */
if (max_search_rad == 1)
update_mode = VectorUpdatePGS1;
else if (max_search_rad == 2)
update_mode = VectorUpdatePGS2;
else if (max_search_rad == 3)
update_mode = VectorUpdatePGS3;
else
update_mode = VectorUpdatePGS4;
handle = InitVectorUpdate(tmpRF, update_mode);
FinalizeVectorUpdate(handle);
}
rpx = rand_path[n][0];
rpy = rand_path[n][1];
rpz = rand_path[n][2];
ix2 = rpx; while (ix2 < ix)
ix2 += iLxp1;
iy2 = rpy; while (iy2 < iy)
iy2 += iLyp1;
iz2 = rpz; while (iz2 < iz)
iz2 += iLzp1;
/* This if clause checks to see if there are, in fact,
* any points at all in this subgrid, for this
* particular region. Note that each value of n in the
* above n-loop corresponds to a different region. */
if ((ix2 < ix + nx) && (iy2 < iy + ny) && (iz2 < iz + nz))
{
/*
* Construct the input matrix and vector for kriging,
* solve the linear system, and compute csigma.
* These depend only on the spatial distribution of
* conditioning data, not on the actual values of
* the data. Only the conditional mean (cmean) depends
* on actual values, so it must be computed for every
* point. Thus, it's found within the pgs_Boxloop below.
* The size of the linear system that must be solved here
* will be no larger than (2r+1)^3, where r=max_search_rad.
* It is clear from this why it is necessary to limit
* the size of the search radius.
*/
/* Here the marker array indicates which points within
* the search radius have been simulated already. This
* spatial pattern of conditioning points will be the
* same for every point in the current template. Thus,
* this system can be solved once *outside* of the
* GrGeomInLoop2 below. */
npts = 9999;
while (npts > max_npts)
{
m = 0;
/* Count the number of points in search ellipse */
for (k = rpz - k_search; k <= rpz + k_search; k++)
for (j = rpy - j_search; j <= rpy + j_search; j++)
for (i = rpx - i_search; i <= rpx + i_search; i++)
{
if (marker[i][j][k])
{
ixx[m] = i;
iyy[m] = j;
izz[m++] = k;
}
}
npts = m;
/* If npts is too large, reduce the size of the
* search ellipse one axis at a time. */
if (npts > max_npts)
{
/* If i_search is the biggest, reduce it by one. */
if ((i_search >= j_search) && (i_search >= k_search))
{
i_search--;
}
/* Or, if j_search is the biggest, reduce it by one. */
else if ((j_search >= i_search) && (j_search >= k_search))
{
j_search--;
}
/* Otherwise, reduce k_search by one. */
else
{
k_search--;
}
}
}
m = 0;
for (j = 0; j < npts; j++)
{
di = abs(rpx - ixx[j]);
dj = abs(rpy - iyy[j]);
dk = abs(rpz - izz[j]);
b[j] = cov[di][dj][dk];
for (i = 0; i < npts; i++)
{
di = abs(ixx[i] - ixx[j]);
dj = abs(iyy[i] - iyy[j]);
dk = abs(izz[i] - izz[j]);
A11[m++] = cov[di][dj][dk];
}
}
/* Solve the linear system */
for (i = 0; i < npts; i++)
w[i] = b[i];
if (npts > 0)
{
dpofa_(A11, &npts, &npts, &ierr);
dposl_(A11, &npts, &npts, w);
}
/* Compute the conditional standard deviation for the RV
* to be simulated. */
csigma = 0.0;
for (i = 0; i < npts; i++)
csigma += w[i] * b[i];
csigma = sqrt(cov[0][0][0] - csigma);
/* The following loop hits every point in the current
* region. That is, it skips by max_search_rad+1
* through the subgrid. In this way, all the points
* in this loop may simulated simultaneously; each is
* outside the search radius of all the others. */
nxG = (nx + ix);
nyG = (ny + iy);
nzG = (nz + iz);
for (k = iz2; k < nzG; k += iLzp1)
for (j = iy2; j < nyG; j += iLyp1)
for (i = ix2; i < nxG; i += iLxp1)
{
index1 = SubvectorEltIndex(sub_field, i, j, k);
index2 = SubvectorEltIndex(sub_tmpRF, i, j, k);
/* Only simulate points in this geounit and that don't
* already have a value. If a node already has a value,
* it was assigned as external conditioning data,
* so we don't need to simulate it. */
if (fabs(tmpRFp[index2]) < Tiny)
{
/* Condition the random variable */
m = 0;
cpts = 0;
for (kk = -k_search; kk <= k_search; kk++)
for (jj = -j_search; jj <= j_search; jj++)
for (ii = -i_search; ii <= i_search; ii++)
{
value[m] = 0.0;
index3 = SubvectorEltIndex(sub_tmpRF, i + ii, j + jj, k + kk);
if (marker[ii + rpx][jj + rpy][kk + rpz])
{
value[m++] = tmpRFp[index3];
}
/* In this case, there is a value at this point,
* but it wasn't simulated yet (as indicated by the
* fact that the marker has no place for it). Thus,
* it must be external conditioning data. */
else if (fabs(tmpRFp[index3]) > Tiny)
{
ixx[npts + cpts] = rpx + ii;
iyy[npts + cpts] = rpy + jj;
izz[npts + cpts] = rpz + kk;
cval[cpts++] = tmpRFp[index3];
}
}
/* If cpts is too large, reduce the size of the
* search neighborhood, one axis at a time. */
/* Define the size of the search neighborhood */
ci_search = i_search;
cj_search = j_search;
ck_search = k_search;
while (cpts > max_cpts)
{
/* If ci_search is the biggest, reduce it by one. */
if ((ci_search >= cj_search) && (ci_search >= ck_search))
ci_search--;
/* Or, if cj_search is the biggest, reduce it by one. */
else if ((cj_search >= ci_search) && (cj_search >= ck_search))
cj_search--;
/* Otherwise, reduce ck_search by one. */
else
ck_search--;
/* Now recount the conditioning data points */
m = 0;
cpts = 0;
for (kk = -ck_search; kk <= ck_search; kk++)
for (jj = -cj_search; jj <= cj_search; jj++)
for (ii = -ci_search; ii <= ci_search; ii++)
{
index3 = SubvectorEltIndex(sub_tmpRF, i + ii, j + jj, k + kk);
if (!(marker[rpx + ii][rpy + jj][rpz + kk]) &&
(fabs(tmpRFp[index3]) > Tiny))
{
ixx[npts + cpts] = rpx + ii;
iyy[npts + cpts] = rpy + jj;
izz[npts + cpts] = rpz + kk;
cval[cpts++] = tmpRFp[index3];
}
}
}
for (i2 = 0; i2 < npts; i2++)
w_tmp[i2] = w[i2];
/*--------------------------------------------------
* Conditioning to external data is done here.
*--------------------------------------------------*/
if (cpts > 0)
{
/* Compute the submatrices */
for (j2 = 0; j2 < npts + cpts; j2++)
{
di = abs(rpx - ixx[j2]);
dj = abs(rpy - iyy[j2]);
dk = abs(rpz - izz[j2]);
b[j2] = cov[di][dj][dk];
for (i2 = 0; i2 < npts + cpts; i2++)
{
di = abs(ixx[i2] - ixx[j2]);
dj = abs(iyy[i2] - iyy[j2]);
dk = abs(izz[i2] - izz[j2]);
A = cov[di][dj][dk];
if (i2 < npts && j2 >= npts)
A12[i2][j2 - npts] = A;
if (i2 >= npts && j2 < npts)
A21[i2 - npts][j2] = A;
if (i2 >= npts && j2 >= npts)
A22[i2 - npts][j2 - npts] = A;
}
}
/* Compute b2' = b2 - A21 * A11_inv * b1 and augment b1 */
for (i2 = 0; i2 < cpts; i2++)
b2[i2] = b[i2 + npts];
for (i2 = 0; i2 < npts; i2++)
b_tmp[i2] = b[i2];
dposl_(A11, &npts, &npts, b_tmp);
for (i2 = 0; i2 < cpts; i2++)
{
sum = 0.0;
for (j2 = 0; j2 < npts; j2++)
{
sum += A21[i2][j2] * b_tmp[j2];
}
b2[i2] -= sum;
}
for (i2 = 0; i2 < cpts; i2++)
b[i2 + npts] = b2[i2];
/* Compute A22' = A22 - A21 * A11_inv * A12 */
for (j2 = 0; j2 < cpts; j2++)
for (i2 = 0; i2 < npts; i2++)
M[j2][i2] = A12[i2][j2];
if (npts > 0)
{
for (i2 = 0; i2 < cpts; i2++)
dposl_(A11, &npts, &npts, M[i2]);
}
for (j2 = 0; j2 < cpts; j2++)
for (i2 = 0; i2 < cpts; i2++)
{
sum = 0.0;
for (k2 = 0; k2 < npts; k2++)
sum += A21[i2][k2] * M[j2][k2];
A22[i2][j2] -= sum;
}
m = 0;
for (j2 = 0; j2 < cpts; j2++)
for (i2 = 0; i2 < cpts; i2++)
A_sub[m++] = A22[i2][j2];
/* Compute x2 where A22*x2 = b2' */
dpofa_(A_sub, &cpts, &cpts, &ierr);
dposl_(A_sub, &cpts, &cpts, b2);
/* Compute w_tmp where A11*w_tmp = (b1 - A12*b2) */
if (npts > 0)
{
for (i2 = 0; i2 < npts; i2++)
{
sum = 0.0;
for (k2 = 0; k2 < cpts; k2++)
sum += A12[i2][k2] * b2[k2];
w_tmp[i2] = b[i2] - sum;
}
dposl_(A11, &npts, &npts, w_tmp);
}
/* Fill in the rest of w_tmp with b2 */
for (i2 = npts; i2 < npts + cpts; i2++)
{
w_tmp[i2] = b2[i2];
value[i2] = cval[i2 - npts];
}
/* Recompute csigma */
csigma = 0.0;
for (i2 = 0; i2 < npts + cpts; i2++)
csigma += w_tmp[i2] * b[i2];
csigma = sqrt(cov[0][0][0] - csigma);
}
/*--------------------------------------------------
* End of external conditioning
*--------------------------------------------------*/
cmean = 0.0;
for (m = 0; m < npts + cpts; m++)
cmean += w_tmp[m] * value[m];
/* uni = fieldp[index1]; */
uni = Rand();
gauinv_(&uni, &gau, &ierr);
tmpRFp[index2] = csigma * gau + cmean;
/* Cutoff tail values if required */
if (dist_type > 1)
{
if (tmpRFp[index2] < low_cutoff)
tmpRFp[index2] = low_cutoff;
if (tmpRFp[index2] > high_cutoff)
tmpRFp[index2] = high_cutoff;
}
} /* if( abs(tmpRFp[index2]) < Tiny ) */
}
/* end of triple for-loops over i,j,k */
/* Update the marker vector */
imin = rpx - iLxp1; if (imin < -iLx)
imin += iLxp1;
jmin = rpy - iLyp1; if (jmin < -iLy)
jmin += iLyp1;
kmin = rpz - iLzp1; if (kmin < -iLz)
kmin += iLzp1;
for (kk = kmin; kk <= 2 * iLz; kk += iLzp1)
for (jj = jmin; jj <= 2 * iLy; jj += iLyp1)
for (ii = imin; ii <= 2 * iLx; ii += iLxp1)
{
marker[ii][jj][kk] = 1;
}
} /* if(...) */
} /* n loop */
/* Make log-normal if requested. Note that low
* and high cutoffs are already accomplished. */
if ((dist_type == 1) || (dist_type == 3))
{
GrGeomInLoop(i, j, k, gr_geounit, ref, ix, iy, iz, nx, ny, nz,
{
index1 = SubvectorEltIndex(sub_field, i, j, k);
index2 = SubvectorEltIndex(sub_tmpRF, i, j, k);
fieldp[index1] = mean * exp((sigma) * tmpRFp[index2]);
});
int64 Random::Int64() {
return (static_cast<uint64>(Rand()) << 32) | static_cast<uint64>(Rand());
}
void LootMgr::PushLoot(StoreLootList *list,Loot * loot, uint8 difficulty, uint8 team, bool disenchant)
{
uint32 i;
uint32 count;
float nrand = 0;
float ncount = 0;
assert(difficulty < 4);
if (disenchant)
{
nrand = RandomUInt(10000) / 100.0f;
ncount = 0;
}
for( uint32 x = 0; x < list->count; x++ )
{
if( list->items[x].item.itemproto )// this check is needed until loot DB is fixed
{
float chance = list->items[x].chance[difficulty];
if(chance == 0.0f)
continue;
ItemPrototype *itemproto = list->items[x].item.itemproto;
if(!CheckItemFaction(itemproto->Faction, team))
continue;
int lucky;
if (disenchant)
{
lucky = nrand >= ncount && nrand <= (ncount+chance);
ncount+= chance;
}
else
lucky = Rand( chance * sWorld.getRate( RATE_DROP0 + itemproto->Quality ) );
if( lucky )
{
if( list->items[x].mincount == list->items[x].maxcount )
count = list->items[x].maxcount;
else
count = RandomUInt(list->items[x].maxcount - list->items[x].mincount) + list->items[x].mincount;
for( i = 0; i < loot->items.size(); i++ )
{
//itemid rand match a already placed item, if item is stackable and unique(stack), increment it, otherwise skips
if((loot->items[i].item.itemproto == list->items[x].item.itemproto) && itemproto->MaxCount && ((loot->items[i].StackSize + count) < itemproto->MaxCount))
{
if(itemproto->Unique && ((loot->items[i].StackSize+count) < itemproto->Unique))
{
loot->items[i].StackSize += count;
break;
}
else if (!itemproto->Unique)
{
loot->items[i].StackSize += count;
break;
}
}
}
if( i != loot->items.size() )
continue;
__LootItem itm;
itm.item =list->items[x].item;
itm.StackSize = count;
itm.roll = NULLROLL;
itm.passed = false;
itm.ffa_loot = list->items[x].ffa_loot;
itm.has_looted.clear();
if( itemproto->Quality > 1 && itemproto->ContainerSlots == 0 )
{
itm.iRandomProperty=GetRandomProperties( itemproto );
itm.iRandomSuffix=GetRandomSuffix( itemproto );
}
else
{
// save some calls :P
itm.iRandomProperty = NULL;
itm.iRandomSuffix = NULL;
}
loot->items.push_back(itm);
}
}
}
if( loot->items.size() > 16 )
{
std::vector<__LootItem>::iterator item_to_remove;
std::vector<__LootItem>::iterator itr;
uint32 item_quality;
bool quest_item;
while( loot->items.size() > 16 )
{
item_to_remove = loot->items.begin();
item_quality = 0;
quest_item = false;
for( itr = loot->items.begin(); itr != loot->items.end(); itr++ )
{
item_quality = (*itr).item.itemproto->Quality;
quest_item = (*itr).item.itemproto->Class == ITEM_CLASS_QUEST;
if( (*item_to_remove).item.itemproto->Quality > item_quality && !quest_item )
{
item_to_remove = itr;
}
}
loot->items.erase( item_to_remove );
}
}
}
// Management thread
void NiAdminThread(THREAD *thread, void *param)
{
NAT_ADMIN *a = (NAT_ADMIN *)param;
NAT *n;
SOCK *s;
UCHAR random[SHA1_SIZE];
UINT err;
// Validate arguments
if (thread == NULL || param == NULL)
{
return;
}
// Random number generation
Rand(random, sizeof(random));
a->Thread = thread;
AddRef(a->Thread->ref);
s = a->Sock;
AddRef(s->ref);
n = a->Nat;
LockList(n->AdminList);
{
Add(n->AdminList, a);
}
UnlockList(n->AdminList);
NoticeThreadInit(thread);
err = ERR_AUTH_FAILED;
if (StartSSL(s, n->AdminX, n->AdminK))
{
PACK *p;
// Send the random number
p = NewPack();
PackAddData(p, "auth_random", random, sizeof(random));
if (HttpServerSend(s, p))
{
PACK *p;
// Receive a password
p = HttpServerRecv(s);
if (p != NULL)
{
UCHAR secure_password[SHA1_SIZE];
UCHAR secure_check[SHA1_SIZE];
if (PackGetData2(p, "secure_password", secure_password, sizeof(secure_password)))
{
SecurePassword(secure_check, n->HashedPassword, random);
if (Cmp(secure_check, secure_password, SHA1_SIZE) == 0)
{
UCHAR test[SHA1_SIZE];
// Password match
Hash(test, "", 0, true);
SecurePassword(test, test, random);
#if 0
if (Cmp(test, secure_check, SHA1_SIZE) == 0 && s->RemoteIP.addr[0] != 127)
{
// A client can not connect from the outside with blank password
err = ERR_NULL_PASSWORD_LOCAL_ONLY;
}
else
#endif
{
// Successful connection
err = ERR_NO_ERROR;
NiAdminMain(n, s);
}
}
}
FreePack(p);
}
}
FreePack(p);
if (err != ERR_NO_ERROR)
{
p = PackError(err);
HttpServerSend(s, p);
FreePack(p);
}
}
Disconnect(s);
ReleaseSock(s);
}
// Create Cedar object
CEDAR *NewCedar(X *server_x, K *server_k)
{
CEDAR *c;
char tmp[MAX_SIZE];
char tmp2[MAX_SIZE];
char *beta_str;
CedarForceLink();
c = ZeroMalloc(sizeof(CEDAR));
c->CurrentActiveLinks = NewCounter();
c->AcceptingSockets = NewCounter();
c->CedarSuperLock = NewLock();
c->CurrentRegionLock = NewLock();
StrCpy(c->OpenVPNDefaultClientOption, sizeof(c->OpenVPNDefaultClientOption), OVPN_DEF_CLIENT_OPTION_STRING);
#ifdef BETA_NUMBER
c->Beta = BETA_NUMBER;
#endif // BETA_NUMBER
InitNoSslList(c);
c->AssignedBridgeLicense = NewCounter();
c->AssignedClientLicense = NewCounter();
c->CurrentTcpQueueSizeLock = NewLock();
c->QueueBudgetLock = NewLock();
c->FifoBudgetLock = NewLock();
Rand(c->UniqueId, sizeof(c->UniqueId));
c->CreatedTick = Tick64();
c->lock = NewLock();
c->ref = NewRef();
c->OpenVPNPublicPortsLock = NewLock();
c->CurrentTcpConnections = GetNumTcpConnectionsCounter();
c->ListenerList = NewList(CompareListener);
c->UDPEntryList = NewList(CompareUDPEntry);
c->HubList = NewList(CompareHub);
c->ConnectionList = NewList(CompareConnection);
c->ConnectionIncrement = NewCounter();
c->CurrentSessions = NewCounter();
if (server_k && server_x)
{
c->ServerK = CloneK(server_k);
c->ServerX = CloneX(server_x);
}
c->Version = CEDAR_VER;
c->Build = CEDAR_BUILD;
c->ServerStr = CopyStr(CEDAR_SERVER_STR);
GetMachineName(tmp, sizeof(tmp));
c->MachineName = CopyStr(tmp);
c->HttpUserAgent = CopyStr(DEFAULT_USER_AGENT);
c->HttpAccept = CopyStr(DEFAULT_ACCEPT);
c->HttpAcceptLanguage = CopyStr("ja");
c->HttpAcceptEncoding = CopyStr(DEFAULT_ENCODING);
c->Traffic = NewTraffic();
c->TrafficLock = NewLock();
c->CaList = NewList(CompareCert);
c->TrafficDiffList = NewList(NULL);
SetCedarCipherList(c, SERVER_DEFAULT_CIPHER_NAME);
c->ClientId = _II("CLIENT_ID");
c->UdpPortList = NewIntList(false);
InitNetSvcList(c);
InitLocalBridgeList(c);
InitCedarLayer3(c);
c->WebUI = WuNewWebUI(c);
#ifdef ALPHA_VERSION
beta_str = "Alpha";
#else // ALPHA_VERSION
#ifndef RELEASE_CANDIDATE
beta_str = "Beta";
#else // RELEASE_CANDIDATE
beta_str = "Release Candidate";
#endif // RELEASE_CANDIDATE
#endif // ALPHA_VERSION
ToStr(tmp2, c->Beta);
Format(tmp, sizeof(tmp), "Version %u.%02u Build %u %s %s (%s)",
CEDAR_VER / 100, CEDAR_VER - (CEDAR_VER / 100) * 100,
CEDAR_BUILD,
c->Beta == 0 ? "" : beta_str,
c->Beta == 0 ? "" : tmp2,
_SS("LANGSTR"));
Trim(tmp);
if (true)
{
SYSTEMTIME st;
Zero(&st, sizeof(st));
st.wYear = BUILD_DATE_Y;
st.wMonth = BUILD_DATE_M;
st.wDay = BUILD_DATE_D;
c->BuiltDate = SystemToUINT64(&st);
}
c->VerString = CopyStr(tmp);
Format(tmp, sizeof(tmp), "Compiled %04u/%02u/%02u %02u:%02u:%02u by %s at %s",
BUILD_DATE_Y, BUILD_DATE_M, BUILD_DATE_D, BUILD_DATE_HO, BUILD_DATE_MI, BUILD_DATE_SE, BUILDER_NAME, BUILD_PLACE);
c->BuildInfo = CopyStr(tmp);
return c;
}
// Attempts Radius authentication (with specifying retry interval and multiple server)
bool RadiusLogin(CONNECTION *c, char *server, UINT port, UCHAR *secret, UINT secret_size, wchar_t *username, char *password, UINT interval, UCHAR *mschap_v2_server_response_20)
{
UCHAR random[MD5_SIZE];
UCHAR id;
BUF *encrypted_password = NULL;
BUF *user_name = NULL;
//IP ip;
bool ret = false;
TOKEN_LIST *token;
UINT i;
LIST *ip_list;
IPC_MSCHAP_V2_AUTHINFO mschap;
bool is_mschap;
char client_ip_str[MAX_SIZE];
static UINT packet_id = 0;
// Validate arguments
if (server == NULL || port == 0 || (secret_size != 0 && secret == NULL) || username == NULL || password == NULL)
{
return false;
}
Zero(client_ip_str, sizeof(client_ip_str));
if (c != NULL && c->FirstSock != NULL)
{
IPToStr(client_ip_str, sizeof(client_ip_str), &c->FirstSock->RemoteIP);
}
// Parse the MS-CHAP v2 authentication data
Zero(&mschap, sizeof(mschap));
is_mschap = ParseAndExtractMsChapV2InfoFromPassword(&mschap, password);
// Split the server into tokens
token = ParseToken(server, " ,;\t");
// Get the IP address of the server
ip_list = NewListFast(NULL);
for(i = 0; i < token->NumTokens; i++)
{
IP *tmp_ip = Malloc(sizeof(IP));
if (GetIP(tmp_ip, token->Token[i]))
{
Add(ip_list, tmp_ip);
}
else if (GetIPEx(tmp_ip, token->Token[i], true))
{
Add(ip_list, tmp_ip);
}
else
{
Free(tmp_ip);
}
}
FreeToken(token);
if(LIST_NUM(ip_list) == 0)
{
ReleaseList(ip_list);
return false;
}
// Random number generation
Rand(random, sizeof(random));
// ID generation
id = (UCHAR)(packet_id % 254 + 1);
packet_id++;
if (is_mschap == false)
{
// Encrypt the password
encrypted_password = RadiusEncryptPassword(password, random, secret, secret_size);
if (encrypted_password == NULL)
{
// Encryption failure
ReleaseList(ip_list);
return false;
}
}
// Generate the user name packet
user_name = RadiusCreateUserName(username);
if (user_name != NULL)
{
// Generate a password packet
BUF *user_password = (is_mschap ? NULL : RadiusCreateUserPassword(encrypted_password->Buf, encrypted_password->Size));
BUF *nas_id = RadiusCreateNasId(CEDAR_SERVER_STR);
if (is_mschap || user_password != NULL)
{
UINT64 start;
UINT64 next_send_time;
UCHAR tmp[MAX_SIZE];
UINT recv_buf_size = 32768;
UCHAR *recv_buf = MallocEx(recv_buf_size, true);
// Generate an UDP packet
BUF *p = NewBuf();
UCHAR type = 1;
SOCK *sock;
USHORT sz = 0;
UINT pos = 0;
BOOL *finish = ZeroMallocEx(sizeof(BOOL) * LIST_NUM(ip_list), true);
Zero(tmp, sizeof(tmp));
WriteBuf(p, &type, 1);
WriteBuf(p, &id, 1);
WriteBuf(p, &sz, 2);
WriteBuf(p, random, 16);
WriteBuf(p, user_name->Buf, user_name->Size);
if (is_mschap == false)
{
UINT ui;
// PAP
WriteBuf(p, user_password->Buf, user_password->Size);
WriteBuf(p, nas_id->Buf, nas_id->Size);
// Service-Type
ui = Endian32(2);
RadiusAddValue(p, 6, 0, 0, &ui, sizeof(ui));
// NAS-Port-Type
ui = Endian32(5);
RadiusAddValue(p, 61, 0, 0, &ui, sizeof(ui));
// Tunnel-Type
ui = Endian32(1);
RadiusAddValue(p, 64, 0, 0, &ui, sizeof(ui));
// Tunnel-Medium-Type
ui = Endian32(1);
RadiusAddValue(p, 65, 0, 0, &ui, sizeof(ui));
// Calling-Station-Id
RadiusAddValue(p, 31, 0, 0, client_ip_str, StrLen(client_ip_str));
// Tunnel-Client-Endpoint
RadiusAddValue(p, 66, 0, 0, client_ip_str, StrLen(client_ip_str));
}
else
{
// MS-CHAP v2
static UINT session_id = 0;
USHORT us;
UINT ui;
char *ms_ras_version = "MSRASV5.20";
UCHAR ms_chapv2_response[50];
// Acct-Session-Id
us = Endian16(session_id % 254 + 1);
session_id++;
RadiusAddValue(p, 44, 0, 0, &us, sizeof(us));
// NAS-IP-Address
if (c != NULL && c->FirstSock != NULL && c->FirstSock->IPv6 == false)
{
ui = IPToUINT(&c->FirstSock->LocalIP);
RadiusAddValue(p, 4, 0, 0, &ui, sizeof(ui));
}
// Service-Type
ui = Endian32(2);
RadiusAddValue(p, 6, 0, 0, &ui, sizeof(ui));
// MS-RAS-Vendor
ui = Endian32(311);
RadiusAddValue(p, 26, 311, 9, &ui, sizeof(ui));
// MS-RAS-Version
RadiusAddValue(p, 26, 311, 18, ms_ras_version, StrLen(ms_ras_version));
// NAS-Port-Type
ui = Endian32(5);
RadiusAddValue(p, 61, 0, 0, &ui, sizeof(ui));
// Tunnel-Type
ui = Endian32(1);
RadiusAddValue(p, 64, 0, 0, &ui, sizeof(ui));
// Tunnel-Medium-Type
ui = Endian32(1);
RadiusAddValue(p, 65, 0, 0, &ui, sizeof(ui));
// Calling-Station-Id
RadiusAddValue(p, 31, 0, 0, client_ip_str, StrLen(client_ip_str));
// Tunnel-Client-Endpoint
RadiusAddValue(p, 66, 0, 0, client_ip_str, StrLen(client_ip_str));
// MS-RAS-Client-Version
RadiusAddValue(p, 26, 311, 35, ms_ras_version, StrLen(ms_ras_version));
// MS-RAS-Client-Name
RadiusAddValue(p, 26, 311, 34, client_ip_str, StrLen(client_ip_str));
// MS-CHAP-Challenge
RadiusAddValue(p, 26, 311, 11, mschap.MsChapV2_ServerChallenge, sizeof(mschap.MsChapV2_ServerChallenge));
// MS-CHAP2-Response
Zero(ms_chapv2_response, sizeof(ms_chapv2_response));
Copy(ms_chapv2_response + 2, mschap.MsChapV2_ClientChallenge, 16);
Copy(ms_chapv2_response + 2 + 16 + 8, mschap.MsChapV2_ClientResponse, 24);
RadiusAddValue(p, 26, 311, 25, ms_chapv2_response, sizeof(ms_chapv2_response));
// NAS-ID
WriteBuf(p, nas_id->Buf, nas_id->Size);
}
SeekBuf(p, 0, 0);
WRITE_USHORT(((UCHAR *)p->Buf) + 2, (USHORT)p->Size);
// Create a socket
sock = NewUDPEx(0, IsIP6(LIST_DATA(ip_list, pos)));
// Transmission process start
start = Tick64();
if(interval < RADIUS_RETRY_INTERVAL)
{
interval = RADIUS_RETRY_INTERVAL;
}
else if(interval > RADIUS_RETRY_TIMEOUT)
{
interval = RADIUS_RETRY_TIMEOUT;
}
next_send_time = start + (UINT64)interval;
while (true)
{
UINT server_port;
UINT recv_size;
//IP server_ip;
SOCKSET set;
UINT64 now;
SEND_RETRY:
//SendTo(sock, &ip, port, p->Buf, p->Size);
SendTo(sock, LIST_DATA(ip_list, pos), port, p->Buf, p->Size);
Debug("send to host:%u\n", pos);
next_send_time = Tick64() + (UINT64)interval;
RECV_RETRY:
now = Tick64();
if (next_send_time <= now)
{
// Switch the host to refer
pos++;
pos = pos % LIST_NUM(ip_list);
goto SEND_RETRY;
}
if ((start + RADIUS_RETRY_TIMEOUT) < now)
{
// Time-out
break;
}
InitSockSet(&set);
AddSockSet(&set, sock);
Select(&set, (UINT)(next_send_time - now), NULL, NULL);
recv_size = RecvFrom(sock, LIST_DATA(ip_list, pos), &server_port, recv_buf, recv_buf_size);
if (recv_size == 0)
{
Debug("Radius recv_size 0\n");
finish[pos] = TRUE;
for(i = 0; i < LIST_NUM(ip_list); i++)
{
if(finish[i] == FALSE)
{
// Switch the host to refer
pos++;
pos = pos % LIST_NUM(ip_list);
goto SEND_RETRY;
}
}
// Failure
break;
}
else if (recv_size == SOCK_LATER)
{
// Waiting
goto RECV_RETRY;
}
else
{
// Check such as the IP address
if (/*Cmp(&server_ip, &ip, sizeof(IP)) != 0 || */server_port != port)
{
goto RECV_RETRY;
}
// Success
if (recv_buf[0] == 2)
{
ret = true;
if (is_mschap && mschap_v2_server_response_20 != NULL)
{
// Cutting corners Zurukko
UCHAR signature[] = {0x1A, 0x33, 0x00, 0x00, 0x01, 0x37, 0x1A, 0x2D, 0x00, 0x53, 0x3D, };
UINT i = SearchBin(recv_buf, 0, recv_buf_size, signature, sizeof(signature));
if (i == INFINITE || ((i + sizeof(signature) + 40) > recv_buf_size))
{
ret = false;
}
else
{
char tmp[MAX_SIZE];
BUF *b;
Zero(tmp, sizeof(tmp));
Copy(tmp, recv_buf + i + sizeof(signature), 40);
b = StrToBin(tmp);
if (b != NULL && b->Size == 20)
{
WHERE;
Copy(mschap_v2_server_response_20, b->Buf, 20);
}
else
{
WHERE;
ret = false;
}
FreeBuf(b);
}
}
}
break;
}
}
Free(finish);
// Release the socket
ReleaseSock(sock);
FreeBuf(p);
FreeBuf(user_password);
Free(recv_buf);
}
FreeBuf(nas_id);
FreeBuf(user_name);
}
// Release the ip_list
for(i = 0; i < LIST_NUM(ip_list); i++)
{
IP *tmp_ip = LIST_DATA(ip_list, i);
Free(tmp_ip);
}
ReleaseList(ip_list);
// Release the memory
FreeBuf(encrypted_password);
return ret;
}
/* comefrom: processEvent */
doKeyDown(SimView *view, short charCode)
{
LastKeys[0] = LastKeys[1];
LastKeys[1] = LastKeys[2];
LastKeys[2] = LastKeys[3];
LastKeys[3] = tolower(charCode);
if (strcmp(LastKeys, "fund") == 0) {
Spend(-10000);
PunishCnt++; /* punish for cheating */
if (PunishCnt == 5) {
PunishCnt = 0;
MakeEarthquake();
}
LastKeys[0] = '\0';
} else if (strcmp(LastKeys, "fart") == 0) {
MakeSound("city", "Explosion-High");
MakeSound("city", "Explosion-Low");
MakeFire();
MakeFlood();
MakeTornado();
MakeEarthquake();
MakeMonster();
LastKeys[0] = '\0';
} else if (strcmp(LastKeys, "nuke") == 0) {
int i, j;
MakeSound("city", "Explosion-High");
MakeSound("city", "Explosion-Low");
for (i = 0; i < WORLD_X; i++) {
for (j = 0; j < WORLD_Y; j++) {
short tile = Map[i][j] & LOMASK;
if ((tile >= RUBBLE) &&
((tile < CHURCH - 4) ||
(tile > CHURCH + 4))) {
if ((tile >= HBRIDGE && tile <= VBRIDGE) ||
(tile >= BRWH && tile <= LTRFBASE + 1) ||
(tile >= BRWV && tile <= BRWV + 2) ||
(tile >= BRWXXX1 && tile <= BRWXXX1 + 2) ||
(tile >= BRWXXX2 && tile <= BRWXXX2 + 2) ||
(tile >= BRWXXX3 && tile <= BRWXXX3 + 2) ||
(tile >= BRWXXX4 && tile <= BRWXXX4 + 2) ||
(tile >= BRWXXX5 && tile <= BRWXXX5 + 2) ||
(tile >= BRWXXX6 && tile <= BRWXXX6 + 2) ||
(tile >= BRWXXX7 && tile <= BRWXXX7 + 2)) {
Map[i][j] = RIVER;
} else {
Map[i][j] = TINYEXP + ANIMBIT + BULLBIT + Rand(2);
}
}
}
}
LastKeys[0] = '\0';
} else if (strcmp(LastKeys, "stop") == 0) {
heat_steps = 0;
LastKeys[0] = '\0';
Kick();
} else if (strcmp(LastKeys, "will") == 0) {
int i;
int n = 500;
for (i = 0; i < n; i++) {
int x1 = Rand(WORLD_X - 1);
int y1 = Rand(WORLD_Y - 1);
int x2 = Rand(WORLD_X - 1);
int y2 = Rand(WORLD_Y - 1);
short temp =
Map[x1][y1];
Map[x1][y1] =
Map[x2][y2];
Map[x2][y2] =
temp;
}
Kick();
} else if (strcmp(LastKeys, "bobo") == 0) {
heat_steps = 1;
heat_flow = -1;
heat_rule = 0;
LastKeys[0] = '\0';
Kick();
} else if (strcmp(LastKeys, "boss") == 0) {
heat_steps = 1;
heat_flow = 1;
heat_rule = 0;
LastKeys[0] = '\0';
Kick();
} else if (strcmp(LastKeys, "mack") == 0) {
heat_steps = 1;
heat_flow = 0;
heat_rule = 0;
LastKeys[0] = '\0';
Kick();
} else if (strcmp(LastKeys, "donh") == 0) {
heat_steps = 1;
heat_flow = -1;
heat_rule = 1;
LastKeys[0] = '\0';
Kick();
} else if (strcmp(LastKeys, "patb") == 0) {
heat_steps = 1;
heat_flow = Rand(40) - 20;
heat_rule = 0;
LastKeys[0] = '\0';
Kick();
} else if (strcmp(LastKeys, "lucb") == 0) {
heat_steps = 1;
heat_flow = Rand(1000) - 500;
heat_rule = 0;
LastKeys[0] = '\0';
Kick();
} else if (strcmp(LastKeys, "olpc") == 0) {
Spend(-1000000);
}
switch (charCode) {
case 'X':
case 'x': {
short s = view->tool_state;
if (++s > lastState) {
s = firstState;
}
setWandState(view, s);
break;
}
case 'Z':
case 'z': {
short s = view->tool_state;
if (--s < firstState) {
s = lastState;
}
setWandState(view, s);
break;
}
/***** shift wand state to bull dozer *****/
case 'B':
case 'b':
case 'B'-'@': {
if (view->tool_state_save == -1) {
view->tool_state_save = view->tool_state;
}
setWandState(view, dozeState);
break;
}
/***** shift wand state to roads *****/
case 'R':
case 'r':
case 'R'-'@': {
if (view->tool_state_save == -1) {
view->tool_state_save = view->tool_state;
}
setWandState(view, roadState);
break;
}
/***** shift wand state to power *****/
case 'P':
case 'p':
case 'P'-'@': {
if (view->tool_state_save == -1) {
view->tool_state_save = view->tool_state;
}
setWandState(view, wireState);
break;
}
/***** shift wand state to transit *****/
case 'T':
case 't':
case 'T'-'@': {
if (view->tool_state_save == -1) {
view->tool_state_save = view->tool_state;
}
setWandState(view, rrState);
break;
}
#if 0
/***** shift wand state to query *****/
case 'Q':
case 'q':
case 'Q'-'@': {
if (view->tool_state_save == -1)
view->tool_state_save = view->tool_state;
setWandState(view, queryState);
break;
}
#endif
case 27: {
SoundOff();
break;
}
}
}
void RandomVector(Vector& b,Real range)
{
for(int i=0;i<b.n;i++) b(i)=Rand(-range,range);
}
void DataTransformer<Dtype>::Transform(const cv::Mat& cv_img,
Blob<Dtype>* transformed_blob) {
const int crop_size = param_.crop_size();
const int img_channels = cv_img.channels();
const int img_height = cv_img.rows;
const int img_width = cv_img.cols;
// Check dimensions.
const int channels = transformed_blob->channels();
const int height = transformed_blob->height();
const int width = transformed_blob->width();
const int num = transformed_blob->num();
CHECK_EQ(channels, img_channels);
CHECK_LE(height, img_height);
CHECK_LE(width, img_width);
CHECK_GE(num, 1);
CHECK(cv_img.depth() == CV_8U) << "Image data type must be unsigned byte";
const Dtype scale = param_.scale();
const bool do_mirror = param_.mirror() && Rand(2);
const bool has_mean_file = param_.has_mean_file();
const bool has_mean_values = mean_values_.size() > 0;
CHECK_GT(img_channels, 0);
CHECK_GE(img_height, crop_size);
CHECK_GE(img_width, crop_size);
Dtype* mean = NULL;
if (has_mean_file) {
CHECK_EQ(img_channels, data_mean_.channels());
CHECK_EQ(img_height, data_mean_.height());
CHECK_EQ(img_width, data_mean_.width());
mean = data_mean_.mutable_cpu_data();
}
if (has_mean_values) {
CHECK(mean_values_.size() == 1 || mean_values_.size() == img_channels) <<
"Specify either 1 mean_value or as many as channels: " << img_channels;
if (img_channels > 1 && mean_values_.size() == 1) {
// Replicate the mean_value for simplicity
for (int c = 1; c < img_channels; ++c) {
mean_values_.push_back(mean_values_[0]);
}
}
}
int h_off = 0;
int w_off = 0;
cv::Mat cv_cropped_img = cv_img;
if (crop_size) {
CHECK_EQ(crop_size, height);
CHECK_EQ(crop_size, width);
// We only do random crop when we do training.
if (phase_ == TRAIN) {
h_off = Rand(img_height - crop_size + 1);
w_off = Rand(img_width - crop_size + 1);
} else {
h_off = (img_height - crop_size) / 2;
w_off = (img_width - crop_size) / 2;
}
cv::Rect roi(w_off, h_off, crop_size, crop_size);
cv_cropped_img = cv_img(roi);
} else {
CHECK_EQ(img_height, height);
CHECK_EQ(img_width, width);
}
CHECK(cv_cropped_img.data);
Dtype* transformed_data = transformed_blob->mutable_cpu_data();
int top_index;
for (int h = 0; h < height; ++h) {
const uchar* ptr = cv_cropped_img.ptr<uchar>(h);
int img_index = 0;
for (int w = 0; w < width; ++w) {
for (int c = 0; c < img_channels; ++c) {
if (do_mirror) {
top_index = (c * height + h) * width + (width - 1 - w);
} else {
top_index = (c * height + h) * width + w;
}
// int top_index = (c * height + h) * width + w;
Dtype pixel = static_cast<Dtype>(ptr[img_index++]);
if (has_mean_file) {
int mean_index = (c * img_height + h_off + h) * img_width + w_off + w;
transformed_data[top_index] =
(pixel - mean[mean_index]) * scale;
} else {
if (has_mean_values) {
transformed_data[top_index] =
(pixel - mean_values_[c]) * scale;
} else {
transformed_data[top_index] = pixel * scale;
}
}
}
}
}
}
InitSprite(SimSprite *sprite, int x, int y)
{
sprite->x = x; sprite->y = y;
sprite->frame = 0;
sprite->orig_x = sprite->orig_y = 0;
sprite->dest_x = sprite->dest_y = 0;
sprite->count = sprite->sound_count = 0;
sprite->dir = sprite->new_dir = 0;
sprite->step = sprite->flag = 0;
sprite->control = -1;
sprite->turn = 0;
sprite->accel = 0;
sprite->speed = 100;
if (GlobalSprites[sprite->type] == NULL) {
GlobalSprites[sprite->type] = sprite;
}
switch (sprite->type) {
case TRA:
sprite->width = sprite->height = 32;
sprite->x_offset = 32; sprite->y_offset = -16;
sprite->x_hot = 40; sprite->y_hot = -8;
sprite->frame = 1;
sprite->dir = 4;
break;
case SHI:
sprite->width = sprite->height = 48;
sprite->x_offset = 32; sprite->y_offset = -16;
sprite->x_hot = 48; sprite->y_hot = 0;
if (x < (4 <<4)) sprite->frame = 3;
else if (x >= ((WORLD_X - 4) <<4)) sprite->frame = 7;
else if (y < (4 <<4)) sprite->frame = 5;
else if (y >= ((WORLD_Y - 4) <<4)) sprite->frame = 1;
else sprite->frame = 3;
sprite->new_dir = sprite->frame;
sprite->dir = 10;
sprite->count = 1;
break;
case GOD:
sprite->width = sprite->height = 48;
sprite->x_offset = 24; sprite->y_offset = 0;
sprite->x_hot = 40; sprite->y_hot = 16;
if (x > ((WORLD_X <<4) / 2)) {
if (y > ((WORLD_Y <<4) / 2)) sprite->frame = 10;
else sprite->frame = 7;
} else if (y > ((WORLD_Y <<4) / 2)) sprite->frame = 1;
else sprite->frame = 4;
sprite->count = 1000;
sprite->dest_x = PolMaxX <<4;
sprite->dest_y = PolMaxY <<4;
sprite->orig_x = sprite->x;
sprite->orig_y = sprite->y;
break;
case COP:
sprite->width = sprite->height = 32;
sprite->x_offset = 32; sprite->y_offset = -16;
sprite->x_hot = 40; sprite->y_hot = -8;
sprite->frame = 5;
sprite->count = 1500;
sprite->dest_x = Rand((WORLD_X <<4) - 1);
sprite->dest_y = Rand((WORLD_Y <<4) - 1);
sprite->orig_x = x - 30;
sprite->orig_y = y;
break;
case AIR:
sprite->width = sprite->height = 48;
sprite->x_offset = 24; sprite->y_offset = 0;
sprite->x_hot = 48; sprite->y_hot = 16;
if (x > ((WORLD_X - 20) <<4)) {
sprite->x -= 100 + 48;
sprite->dest_x = sprite->x - 200;
sprite->frame = 7;
} else {
sprite->dest_x = sprite->x + 200;
sprite->frame = 11;
}
sprite->dest_y = sprite->y;
break;
case TOR:
sprite->width = sprite->height = 48;
sprite->x_offset = 24; sprite->y_offset = 0;
sprite->x_hot = 40; sprite->y_hot = 36;
sprite->frame = 1;
sprite->count = 200;
break;
case EXP:
sprite->width = sprite->height = 48;
sprite->x_offset = 24; sprite->y_offset = 0;
sprite->x_hot = 40; sprite->y_hot = 16;
sprite->frame = 1;
break;
case BUS:
sprite->width = sprite->height = 32;
sprite->x_offset = 30; sprite->y_offset = -18;
sprite->x_hot = 40; sprite->y_hot = -8;
sprite->frame = 1;
sprite->dir = 1;
break;
}
}
void DataTransformer<Dtype>::Transform(const Datum& datum,
Dtype* transformed_data) {
const string& data = datum.data();
const int datum_channels = datum.channels();
const int datum_height = datum.height();
const int datum_width = datum.width();
const int crop_size = param_.crop_size();
const Dtype scale = param_.scale();
const bool do_mirror = param_.mirror() && Rand(2);
const bool has_mean_file = param_.has_mean_file();
const bool has_uint8 = data.size() > 0;
const bool has_mean_values = mean_values_.size() > 0;
CHECK_GT(datum_channels, 0);
CHECK_GE(datum_height, crop_size);
CHECK_GE(datum_width, crop_size);
Dtype* mean = NULL;
if (has_mean_file) {
CHECK_EQ(datum_channels, data_mean_.channels());
CHECK_EQ(datum_height, data_mean_.height());
CHECK_EQ(datum_width, data_mean_.width());
mean = data_mean_.mutable_cpu_data();
}
if (has_mean_values) {
CHECK(mean_values_.size() == 1 || mean_values_.size() == datum_channels) <<
"Specify either 1 mean_value or as many as channels: " << datum_channels;
if (datum_channels > 1 && mean_values_.size() == 1) {
// Replicate the mean_value for simplicity
for (int c = 1; c < datum_channels; ++c) {
mean_values_.push_back(mean_values_[0]);
}
}
}
int height = datum_height;
int width = datum_width;
int h_off = 0;
int w_off = 0;
if (crop_size) {
height = crop_size;
width = crop_size;
// We only do random crop when we do training.
if (phase_ == TRAIN) {
h_off = Rand(datum_height - crop_size + 1);
w_off = Rand(datum_width - crop_size + 1);
} else {
h_off = (datum_height - crop_size) / 2;
w_off = (datum_width - crop_size) / 2;
}
}
Dtype datum_element;
int top_index, data_index;
for (int c = 0; c < datum_channels; ++c) {
for (int h = 0; h < height; ++h) {
for (int w = 0; w < width; ++w) {
data_index = (c * datum_height + h_off + h) * datum_width + w_off + w;
if (do_mirror) {
top_index = (c * height + h) * width + (width - 1 - w);
} else {
top_index = (c * height + h) * width + w;
}
if (has_uint8) {
datum_element =
static_cast<Dtype>(static_cast<uint8_t>(data[data_index]));
} else {
datum_element = datum.float_data(data_index);
}
if (has_mean_file) {
transformed_data[top_index] =
(datum_element - mean[data_index]) * scale;
} else {
if (has_mean_values) {
transformed_data[top_index] =
(datum_element - mean_values_[c]) * scale;
} else {
transformed_data[top_index] = datum_element * scale;
}
}
}
}
}
}
// Process the SSTP control packet reception
void SstpProcessControlPacket(SSTP_SERVER *s, SSTP_PACKET *p)
{
// Validate arguments
if (s == NULL || p == NULL || p->IsControl == false)
{
return;
}
Debug("SSTP Control Packet Recv: Msg = %u, Num = %u\n", p->MessageType, LIST_NUM(p->AttibuteList));
switch (p->MessageType)
{
case SSTP_MSG_CALL_CONNECT_REQUEST: // Receive a connection request from a client
if (s->Aborting == false && s->Disconnecting == false)
{
if (s->Status == SSTP_SERVER_STATUS_REQUEST_PENGING)
{
SSTP_ATTRIBUTE *protocol_id = SstpFindAttribute(p, SSTP_ATTRIB_ENCAPSULATED_PROTOCOL_ID);
if (protocol_id != NULL && protocol_id->DataSize == 2 &&
READ_USHORT(protocol_id->Data) == SSTP_ENCAPSULATED_PROTOCOL_PPP)
{
// Accept the connection request by the PPP protocol
SSTP_PACKET *ret;
// Generation of random numbers
Rand(s->SentNonce, SSTP_NONCE_SIZE);
ret = SstpNewControlPacketWithAnAttribute(SSTP_MSG_CALL_CONNECT_ACK,
SstpNewCryptoBindingRequestAttribute(CERT_HASH_PROTOCOL_SHA256, s->SentNonce));
SstpSendPacket(s, ret);
SstpFreePacket(ret);
s->Status = SSTP_SERVER_STATUS_CONNECTED_PENDING;
s->EstablishedCount++;
}
else
{
// Refuse to accept for a connection request other than the PPP protocol
SSTP_PACKET *ret = SstpNewControlPacketWithAnAttribute(SSTP_MSG_CALL_CONNECT_NAK,
SstpNewStatusInfoAttribute(SSTP_ATTRIB_ENCAPSULATED_PROTOCOL_ID, ATTRIB_STATUS_VALUE_NOT_SUPPORTED));
SstpSendPacket(s, ret);
SstpFreePacket(ret);
}
}
}
break;
case SSTP_MSG_CALL_CONNECTED: // Connection from the client complete
if (s->Aborting == false && s->Disconnecting == false)
{
if (s->Status == SSTP_SERVER_STATUS_CONNECTED_PENDING)
{
s->Status = SSTP_SERVER_STATUS_ESTABLISHED;
Debug("SSTP Connected.\n");
}
}
break;
case SSTP_MSG_CALL_DISCONNECT: // Receive a disconnect request from the client
case SSTP_MSG_CALL_DISCONNECT_ACK:
s->DisconnectRecved = true;
SstpDisconnect(s);
break;
case SSTP_MSG_CALL_ABORT: // Receive a disconnect request from the client
s->AbortReceived = true;
SstpAbort(s);
break;
}
}