AIDribbleAction::AIDribbleAction(const Player* p)
: AIAction(mActionName, p)
{
float bestscore = -1.0f;
Vector3 bestvec;
std::vector<Vector3> tgtvectors;
if(MatchHelpers::distanceToOwnGoal(*p) < 5.0f)
return;
/* TODO: this constant should depend on pitch */
float dribblelen = 10.0f;
const unsigned int numDirections = 16;
for(unsigned int i = 0; i < numDirections; i++) {
Vector3 vec;
vec.x = dribblelen * sin(i * 2 * PI / float(numDirections));
vec.y = dribblelen * cos(i * 2 * PI / float(numDirections));
tgtvectors.push_back(vec);
}
for(auto vec : tgtvectors) {
auto tgtpos = Vector3(p->getPosition() + vec.normalized() * 16.0f);
if(!MatchHelpers::onPitch(*p->getMatch(), tgtpos))
continue;
/* rather dribble towards opponent goal than away from it */
float goalDistCoeff = AIHelpers::scaledCoefficient(MatchHelpers::distanceToOppositeGoal(*p, tgtpos), 100.0f);
/* rather don't dribble near own goal */
float ownGoalDistCoeff = AIHelpers::scaledCoefficient(MatchHelpers::distanceToOwnGoal(*p, tgtpos), 20.0f);
float thisscore = (1.0f - ownGoalDistCoeff) * 0.5f + goalDistCoeff * 0.5f;
for(auto op : MatchHelpers::getOpposingPlayers(*p)) {
float dist = Common::Math::pointToLineDistance(p->getPosition(),
tgtpos,
op->getPosition());
static const float maxdist = dribblelen;
if(dist < maxdist) {
auto po = MatchEntity::vectorFromTo(*p, *op);
po.normalize();
auto dot = std::max(0.1, po.dot(vec.normalized()));
thisscore -= AIHelpers::scaledCoefficient(dist, maxdist) * dot;
if(thisscore <= 0.0) {
break;
}
}
}
thisscore = AIHelpers::checkKickSuccess(*mPlayer, vec, thisscore);
if(thisscore > bestscore) {
bestscore = thisscore;
bestvec = Vector3(vec.normalized() * (0.35f +
0.15f * (1.0f - mPlayer->getSkills().ShotPower)));
}
}
mScore = bestscore;
float dribblecoeff = mPlayer->getTeam()->getAITacticParameters().DribbleActionCoefficient;
mScore *= dribblecoeff;
mAction = boost::shared_ptr<PlayerAction>(new KickBallPA(bestvec));
}
void Vehicle::setRotationToGround()
{
const auto& orig = getRotation();
const auto& pos = getPosition();
Vector3 forward = pos + Common::Math::rotate3D(Vector3(0.0f, 0, 1.0f), orig) * 1.0f;
Vector3 right = pos + Common::Math::rotate3D(Vector3(-1.0f, 0, 0.0f), orig) * 1.0f;
float h1 = getHeightAt(pos.x, pos.z);
float h2 = getHeightAt(forward.x, forward.z);
float h3 = getHeightAt(right.x, right.z);
Vector3 p1(pos.x, h1, pos.z);
Vector3 p2(forward.x, h2, forward.z);
Vector3 p3(right.x, h3, right.z);
Vector3 norm = (p2 - p1).normalized().cross((p3 - p1).normalized());
if(norm.y < 0.0f)
norm = norm * -1.0f;
Vector3 dir = Common::Math::rotate3D(Vector3(-1.0f, 0, 0.0f), orig);
dir.y = 0.0f;
// rotation along the plane
Quaternion rot = Quaternion::getRotationTo(Vector3(0, 1, 0), norm);
// rotation towards heading
// TODO: this auto-orients the vehicle along the X axis for an unknown reason.
Quaternion rot2 = Quaternion::getRotationTo(Vector3(-1, 0, 0), dir);
rot = rot * rot2;
setRotation(orig.slerp(rot, 0.1f));
}
SkImageFilter::SkImageFilter(int inputCount, SkReadBuffer& buffer) {
Common common;
if (common.unflatten(buffer, inputCount)) {
fCropRect = common.cropRect();
fInputCount = common.inputCount();
fInputs = SkNEW_ARRAY(SkImageFilter*, fInputCount);
common.detachInputs(fInputs);
} else {
SkImageFilter::SkImageFilter(int inputCount, SkReadBuffer& buffer)
: fUsesSrcInput(false)
, fCropRect(SkRect(), 0x0)
, fUniqueID(next_image_filter_unique_id()) {
Common common;
if (common.unflatten(buffer, inputCount)) {
this->init(common.inputs(), common.inputCount(), &common.cropRect());
}
}
static void dispatcher( Common< Package > &common, std::vector< Self > &workers ) {
while ( common.processed() < common.worldSize() ) {
Daemon::instance().probe( [&]( Channel channel ) {
Self::processDispatch( common, workers, channel );
},
ChannelType::Master,
100
);
}
}
SkFlattenable* SkMergeImageFilter::CreateProc(SkReadBuffer& buffer) {
Common common;
if (!common.unflatten(buffer, -1)) {
return NULL;
}
const int count = common.inputCount();
bool hasModes = buffer.readBool();
if (hasModes) {
SkAutoSTArray<4, SkXfermode::Mode> modes(count);
SkAutoSTArray<4, uint8_t> modes8(count);
if (!buffer.readByteArray(modes8.get(), count)) {
return NULL;
}
for (int i = 0; i < count; ++i) {
modes[i] = (SkXfermode::Mode)modes8[i];
buffer.validate(SkIsValidMode(modes[i]));
}
if (!buffer.isValid()) {
return NULL;
}
return Create(common.inputs(), count, modes.get(), &common.cropRect(), common.uniqueID());
}
return Create(common.inputs(), count, NULL, &common.cropRect(), common.uniqueID());
}
Vector3 MatchHelpers::ownGoalPosition(const Team& t)
{
const Match* m = t.getMatch();
assert(m);
if(attacksUp(t)) {
return m->convertRelativeToAbsoluteVector(RelVector3(Vector3(0, -1, 0)));
}
else {
return m->convertRelativeToAbsoluteVector(RelVector3(Vector3(0, 1, 0)));
}
}
boost::shared_ptr<PlayerAction> PlayerAIController::actOffPlay(double time)
{
if(MatchHelpers::myTeamInControl(*mPlayer)) {
bool nearest = MatchHelpers::nearestOwnPlayerTo(*mPlayer,
mPlayer->getMatch()->getBall()->getPosition());
bool shouldkickball;
if(mPlayer->getMatch()->getMatchHalf() == MatchHalf::PenaltyShootout) {
unsigned int r = mPlayer->getMatch()->getPenaltyShootout().getRoundNumber();
int shirtnum = 11 - (r % 10);
shouldkickball = mPlayer->getShirtNumber() == shirtnum;
} else {
shouldkickball = mPlayer->getMatch()->getPlayState() == PlayState::OutKickoff ?
mPlayer->getShirtNumber() == 10 :
mPlayer->getMatch()->getPlayState() == PlayState::OutGoalkick ?
mPlayer->isGoalkeeper() : nearest;
}
if(shouldkickball) {
return doRestart(time);
}
else {
if(mPlayer->getMatch()->getMatchHalf() == MatchHalf::PenaltyShootout) {
return AIHelpers::createMoveActionTo(*mPlayer, Vector3(0, 0, 0));
} else {
if(mPlayer->getMatch()->getPlayState() == PlayState::OutKickoff) {
if(mPlayer->getShirtNumber() >= 10)
return AIHelpers::createMoveActionTo(*mPlayer, Vector3(mPlayer->getShirtNumber() == 10 ?
-1.0f : 2.0f, 0, 0));
else
return AIHelpers::createMoveActionTo(*mPlayer,
mPlayer->getMatch()->convertRelativeToAbsoluteVector(mPlayer->getHomePosition()));
}
else {
return mPlayState->actOnRestart(time);
}
}
}
}
else {
if(mPlayer->getMatch()->getPlayState() == PlayState::OutKickoff) {
return AIHelpers::createMoveActionTo(*mPlayer,
mPlayer->getMatch()->convertRelativeToAbsoluteVector(mPlayer->getHomePosition()));
} else if(mPlayer->getMatch()->getMatchHalf() == MatchHalf::PenaltyShootout) {
if(mPlayer->isGoalkeeper()) {
return mPlayState->actOnRestart(time);
} else {
return AIHelpers::createMoveActionTo(*mPlayer, Vector3(0, 0, 0));
}
} else {
return mPlayState->actOnRestart(time);
}
}
}
SkImageFilter::SkImageFilter(int inputCount, SkReadBuffer& buffer)
: fUsesSrcInput(false)
, fUniqueID(next_image_filter_unique_id()) {
Common common;
if (common.unflatten(buffer, inputCount)) {
fCropRect = common.cropRect();
fInputCount = common.inputCount();
fInputs = SkNEW_ARRAY(SkImageFilter*, fInputCount);
common.detachInputs(fInputs);
for (int i = 0; i < fInputCount; ++i) {
if (NULL == fInputs[i] || fInputs[i]->usesSrcInput()) {
fUsesSrcInput = true;
}
}
} else {
static void notifyAll( Common< Package > &common ) {
common.progress();
OutputMessage msg;
msg.tag( Tag::Done );
Daemon::instance().sendAll( msg );
}
boost::shared_ptr<PlayerAction> PlayerAIController::act(double time)
{
switch(mPlayer->getMatch()->getMatchHalf()) {
case MatchHalf::NotStarted:
case MatchHalf::HalfTimePauseEnd:
case MatchHalf::FullTimePauseEnd:
if(mPlayer->getShirtNumber() >= 10 && MatchHelpers::myTeamInControl(*mPlayer))
return AIHelpers::createMoveActionTo(*mPlayer, Vector3(mPlayer->getShirtNumber() == 10 ?
-1.0f : 2.0f, 0, 0));
else
return AIHelpers::createMoveActionTo(*mPlayer,
mPlayer->getMatch()->convertRelativeToAbsoluteVector(mPlayer->getHomePosition()));
case MatchHalf::HalfTimePauseBegin:
case MatchHalf::FullTimePauseBegin:
case MatchHalf::Finished:
return AIHelpers::createMoveActionTo(*mPlayer,
mPlayer->getMatch()->convertRelativeToAbsoluteVector(mPlayer->getTeam()->getPausePosition()));
case MatchHalf::FirstHalf:
case MatchHalf::SecondHalf:
case MatchHalf::ExtraTimeFirstHalf:
case MatchHalf::ExtraTimeSecondHalf:
case MatchHalf::PenaltyShootout:
switch(mPlayer->getMatch()->getPlayState()) {
case PlayState::InPlay:
return mPlayState->act(time);
default:
return actOffPlay(time);
}
}
throw std::runtime_error("AI error: no state handler");
}
AIBlockAction::AIBlockAction(const Player* p)
: AIAction(mActionName, p)
{
// action to move between the opposing player holding the ball
// and own goal
Vector3 owngoal = MatchHelpers::ownGoalPosition(*p);
const Player* op = MatchHelpers::nearestOppositePlayerToBall(*p->getTeam());
float disttogoal = (owngoal - op->getPosition()).length();
Vector3 blockpos = Vector3((op->getPosition() + owngoal) * 0.5f);
mScore = std::min(1.0f, (100.0f - disttogoal) / 50.0f);
for(auto pl : MatchHelpers::getOwnPlayers(*p)) {
if(&*pl == p || pl->isGoalkeeper())
continue;
float disttoown =
Common::Math::pointToLineDistance(blockpos,
owngoal,
pl->getPosition());
if(disttoown < 0.5f) {
mScore = -1.0f;
break;
}
}
if(mScore > 0.0f)
mScore = AIHelpers::checkTacticArea(*p, mScore, blockpos);
mScore *= mPlayer->getTeam()->getAITacticParameters().BlockActionCoefficient;
mAction = AIHelpers::createMoveActionTo(*p, blockpos, 1.0f);
}
ErrorCode OperationStream::ReportFaultInternal(
__in FABRIC_FAULT_TYPE faultType,
__in std::wstring const & errorMessage)
{
secondary_->OnStreamFault(faultType, errorMessage);
return ErrorCode();
}
AIBlockPassAction::AIBlockPassAction(const Player* p)
: AIAction(mActionName, p)
{
// action to move between opposing supporting player and opponent holding the ball
Vector3 owngoal = MatchHelpers::ownGoalPosition(*p);
const Player* op = MatchHelpers::nearestOppositePlayerToBall(*p->getTeam());
Vector3 bestpos(p->getPosition());
mScore = -1.0f;
for(auto pl : MatchHelpers::getOpposingPlayers(*p)) {
if(op == &*pl)
continue;
float disttogoal = (owngoal - pl->getPosition()).length();
if(disttogoal > 50.0f)
continue;
if(pl->getTeam()->isOffsidePosition(op->getPosition()))
continue;
float thisscore = (50.0f - disttogoal) / 50.0f;
if(thisscore > 0.0f) {
thisscore = AIHelpers::checkTacticArea(*p, thisscore, pl->getPosition());
thisscore *= mPlayer->getTeam()->getAITacticParameters().BlockPassActionCoefficient;
if(thisscore > mScore) {
mScore = thisscore;
bestpos = pl->getPosition();
}
}
}
Vector3 tgtpos = Vector3((op->getPosition() + bestpos) * 0.5f);
mAction = AIHelpers::createMoveActionTo(*p, tgtpos, 1.0f);
}
Common::Vector3 MatchHelpers::playerJumpVelocity(const Player& p, const Common::Vector3& dir)
{
if(!p.standing() || p.isAirborne() || dir.z < 0.01f) {
return Vector3();
}
if(dir.length() < 0.1f) {
return Vector3();
}
Vector3 v(dir.normalized());
if(p.isGoalkeeper())
v *= 1.0f + 2.0f * p.getSkills().GoalKeeping;
else
v *= 1.5f + 1.0f * p.getSkills().Heading;
v *= 3.0f;
v.z = Common::clamp(1.5f, v.length(), 4.5f);
return v;
}
void AnimationSystem::InitAnimation(Common &common, Vec2 scale, Vec2 screen) {
animation.mTexture = common.getTextureResource("explosion");
animation.mPos.x = screen.x / 2 * scale.x;
animation.mPos.y = screen.y / 2 * scale.y;
animation.mCurrentFrame = 0;
animation.mFrameTime = 0.0f;
animation.mScale = scale;
}
void Common::Init(int argc, char* argv[]) {
unsigned i = 0;
_logfile = fopen("logfile.txt", "w");
if(!_logfile) {
MessageBox(NULL, TEXT("unable to create logfile"), TEXT("Error"), MB_OK);
}
char delim = 0;
#ifdef _WIN32
delim = '\\';
#endif
assert(0 != delim);
_baseDir = CurrentDirectory();
bool ignoreLedaDir = false;
i = 0;
while(i < argc && !ignoreLedaDir) {
if(!strcmp("--ignoreledadir", argv[i]))
ignoreLedaDir = true;
i++;
}
const char* s;
if(s = getenv("LEDA_DIR")) {
if(!ignoreLedaDir) _baseDir = s;
common.printf("INFO - environment variable 'LEDA_DIR' set to '%s'\n", s);
}
else common.printf("INFO - environment variable 'LEDA_DIR' not set.\n");
i = 0;
while(i < argc - 1) {
if(!strcmp("--basedir", argv[i]))
_baseDir = DirOf(argv[i + 1]);
i++;
}
if(delim != _baseDir.back()) _baseDir += delim;
_baseDir += std::string("res") + delim;
printf("INFO - base directory is '%s'.\n", _baseDir.c_str());
}
AIClearAction::AIClearAction(const Player* p)
: AIAction(mActionName, p)
{
Vector3 tgt = MatchHelpers::oppositeGoalPosition(*p);
float distToOwnGoal = (MatchHelpers::ownGoalPosition(*p) - p->getMatch()->getBall()->getPosition()).length();
float distToOpposingPlayer = MatchEntity::distanceBetween(*p->getMatch()->getBall(),
*MatchHelpers::nearestOppositePlayerToBall(*p->getTeam()));
const float maxDist = 20.0f;
if(distToOpposingPlayer < 10.0f && distToOwnGoal < 50.0f)
mScore = AIHelpers::scaledCoefficient(distToOwnGoal, maxDist);
else
mScore = -1.0f;
if(mScore > 0.0f) {
Vector3 vecToBall = p->getMatch()->getBall()->getPosition() - p->getPosition();
if(vecToBall.null()) {
vecToBall = MatchHelpers::oppositeGoalPosition(*p) - p->getPosition();
}
vecToBall.normalize();
Vector3 kickvec1(vecToBall);
Vector3 kickvec2(vecToBall);
const float sr1 = sin(PI / 4.0f);
const float cr1 = cos(PI / 4.0f);
const float sr2 = sin(-PI / 4.0f);
const float cr2 = cos(-PI / 4.0f);
kickvec1.x = vecToBall.x * cr1 - vecToBall.y * sr1;
kickvec1.y = vecToBall.x * sr1 + vecToBall.y * cr1;
kickvec2.x = vecToBall.x * cr2 - vecToBall.y * sr2;
kickvec2.y = vecToBall.x * sr2 + vecToBall.y * cr2;
kickvec1 *= 50.0f;
kickvec2 *= 50.0f;
float dist1 = (MatchHelpers::ownGoalPosition(*p) - kickvec1).length();
float dist2 = (MatchHelpers::ownGoalPosition(*p) - kickvec2).length();
tgt = Vector3(dist1 > dist2 ? kickvec1 : kickvec2);
tgt.z = tgt.length() * 0.8f;
mScore = AIHelpers::checkKickSuccess(*mPlayer, tgt, mScore);
}
mScore *= mPlayer->getTeam()->getAITacticParameters().ClearActionCoefficient;
mAction = boost::shared_ptr<PlayerAction>(new KickBallPA(tgt, nullptr, false));
}
void SecondaryReplicator::DrainQueueAsyncOperation::FinishWaitForQueueToDrain(Common::AsyncOperationSPtr const & asyncOperation)
{
auto error = dispatchQueue_->EndWaitForQueueToDrain(asyncOperation);
ReplicatorEventSource::Events->SecondaryDrainDispatchQueueDone(
parent_.partitionId_,
parent_.endpointUniqueId_,
queueType_,
static_cast<int>(error.ReadValue()),
drainScenario_);
AsyncOperationSPtr const & thisSPtr = asyncOperation->Parent;
if (error.IsSuccess() && requireServiceAck_)
{
bool cancelRequested = false;
{
AcquireWriteLock grab(lock_);
hasQueueDrainCompletedSuccessfully_ = true;
cancelRequested = isCancelRequested_;
}
if (cancelRequested)
{
{
AcquireWriteLock grab(lock_);
startedComplete_ = true;
}
this->TryComplete(thisSPtr, ErrorCode(Common::ErrorCodeValue::OperationCanceled));
}
else if (isCopyQueue_)
{
CheckIfAllCopyOperationsAcked(thisSPtr);
}
else
{
CheckIfAllReplicationOperationsAcked(thisSPtr);
}
}
else
{
{
AcquireWriteLock grab(lock_);
startedComplete_ = true;
}
thisSPtr->TryComplete(thisSPtr, error);
}
}
JsonValue KVBinaryInputStreamSerializer::loadValue(uint8_t type) {
switch (type) {
case BIN_KV_SERIALIZE_TYPE_INT64: return readIntegerJson<int64_t>(stream);
case BIN_KV_SERIALIZE_TYPE_INT32: return readIntegerJson<int32_t>(stream);
case BIN_KV_SERIALIZE_TYPE_INT16: return readIntegerJson<int16_t>(stream);
case BIN_KV_SERIALIZE_TYPE_INT8: return readIntegerJson<int8_t>(stream);
case BIN_KV_SERIALIZE_TYPE_UINT64: return readIntegerJson<uint64_t>(stream);
case BIN_KV_SERIALIZE_TYPE_UINT32: return readIntegerJson<uint32_t>(stream);
case BIN_KV_SERIALIZE_TYPE_UINT16: return readIntegerJson<uint16_t>(stream);
case BIN_KV_SERIALIZE_TYPE_UINT8: return readIntegerJson<uint8_t>(stream);
case BIN_KV_SERIALIZE_TYPE_DOUBLE: return readPodJson<double>(stream);
case BIN_KV_SERIALIZE_TYPE_BOOL: return JsonValue(stream.get() != 0);
case BIN_KV_SERIALIZE_TYPE_STRING: return readStringJson(stream);
case BIN_KV_SERIALIZE_TYPE_OBJECT: return loadSection();
case BIN_KV_SERIALIZE_TYPE_ARRAY: return loadArray(type);
default:
throw std::runtime_error("Unknown data type");
break;
}
}
void SecondaryReplicator::DrainQueueAsyncOperation::OnCancel()
{
bool hasQueueDrainedSuccessfully = false;
{
AcquireWriteLock grab(lock_);
isCancelRequested_ = true;
hasQueueDrainedSuccessfully = hasQueueDrainCompletedSuccessfully_;
}
if (hasQueueDrainedSuccessfully)
{
// If the service has finished draining the dispatch queue, but cannot ACK the operations and hence reports fault, we get a cancel call and we must complete ourself
// Or else, this operation will never complete - BUG 1427038
{
AcquireWriteLock grab(lock_);
startedComplete_ = true;
}
this->TryComplete(shared_from_this(), ErrorCode(Common::ErrorCodeValue::OperationCanceled));
}
}
ErrorCode Replicator::ChangeRoleAsyncOperation::CreateInitialSecondary()
{
AcquireWriteLock lock(parent_.lock_);
ASSERT_IF(
parent_.primary_ || parent_.secondary_,
"{0}: The primary and secondary shouldn't exist when changing role to IDLE",
parent_.ToString());
ErrorCode error;
if (newRole_ == ::FABRIC_REPLICA_ROLE_ACTIVE_SECONDARY)
{
error = parent_.state_.TransitionToSecondaryActive();
}
else
{
error = parent_.state_.TransitionToSecondaryIdle();
}
if (!error.IsSuccess())
{
return error;
}
parent_.secondary_ = move(SecondaryReplicator::CreateSecondary(
parent_.config_,
parent_.perfCounters_,
parent_.replicaId_,
parent_.hasPersistedState_,
parent_.endpointUniqueId_,
parent_.stateProvider_,
parent_.partition_,
parent_.version_,
parent_.transport_,
parent_.partitionId_,
parent_.healthClient_,
parent_.apiMonitor_));
return ErrorCode(Common::ErrorCodeValue::Success);
}
int main(int argC, const char* argV[])
{
Common common;
common.report();
TestServer::provideRadarEndpoint(new SocketSensorEndpoint(5003));
TestServer::provideTcasEndpoint(new SocketSensorEndpoint(5002));
TestServer::provideAdsbEndpoint(new SocketSensorEndpoint(5001));
TestServer::provideOwnshipEndpoint(new SocketSensorEndpoint(5000));
//__DIR__ is injected in compile time
std::string test;
if(argC < 2)
{
std::cout << "test-server: <test-file-name.xml>" << std::endl;
return -1;
}
else
{
test = std::string(argV[1]);
}
std::string s(test);
TestFileParser parser;
// true if building test case is successful
try {
if (parser.load(s)) {
std::cout << s << std::endl;
TestCase testCase = parser.GetTestCase();
PositionVerificationTest positionTest(std::make_shared<TestCase>(TestCase(testCase)));
NumPlanesVerificationTest numPlanesTest(std::make_shared<TestCase>(TestCase(testCase)));
//Validator::addTester(std::make_shared<PositionVerificationTest>(std::move(positionTest)));
Validator::addTester(std::make_shared<NumPlanesVerificationTest>(std::move(numPlanesTest)));
TestEnvironment environment;
environment.acceptConnections();
environment.start(testCase);
std::cout << "Environment has finished accepting connections" << std::endl;
}
TestServer::shutdown();
}
catch(std::exception e)
{
std::cerr << "Error in loading test case: " << e.what() << std::endl;
}
/*
std::cout<<"\n----Test File 2----"<<std::endl;
//__DIR__ is injected in compile time
std::string s2(__DIR__"/resources/TestCaseExample2.xml");
// true if building test case is successful
if(parser.load(s2)) {
TestCase tc = parser.GetTestCase();
}
std::cout<<"\n-----Test File 3----"<<std::endl;
//__DIR__ is injected in compile time
std::string s3(__DIR__"/resources/TestCaseExample3.xml");
// true if building test case is successful
if(parser.load(s3)) {
TestCase tc = parser.GetTestCase();
}
}
*/
/*
TestCase testCase;
TestServerPlane ownshipPlane;
ownshipPlane.setMotion(LinearMotion(Vector3d(0,0,8000), Vector3d(875,0,0)));
ownshipPlane.setTailNumber("N00000");
ownshipPlane.setAdsbEnabled(true);
TestServerPlane otherPlane;
otherPlane.setMotion(LinearMotion(Vector3d(5,15,-2000), Vector3d(0,875,0)));
otherPlane.setTailNumber("N12345");
otherPlane.setAdsbEnabled(true);
testCase.setOwnship(ownshipPlane);
testCase.addPlane(otherPlane);
testCase.setTotalTime(10.0f);
//Test cases start at lat 0 long 0
testCase.complete();
TestEnvironment environment;
environment.acceptConnections();
environment.start(testCase);
std::cout << "Environment has finished accepting connections" << std::endl;
TestServer::shutdown();
*/
return 0;
}
void SplitterSystem::InitParams(Common &common) {
params.mTexture = common.getTextureResource("smoke");
getParams();
}
AIPassAction::AIPassAction(const Player* p)
: AIAction(mActionName, p)
{
mScore = -1.0;
Vector3 tgt;
Player* tgtPlayer = nullptr;
mAction = boost::shared_ptr<PlayerAction>(new KickBallPA(MatchHelpers::oppositeGoalPosition(*p),
nullptr, true));
const float riskcoeff = mPlayer->getTeam()->getAITacticParameters().PassRiskCoefficient;
for(auto sp : MatchHelpers::getOwnPlayers(*p)) {
if(sp.get() == p) {
continue;
}
float dist = MatchEntity::distanceBetween(*p, *sp);
if(dist < 10.0 && mPlayer->getMatch()->getPlayState() != PlayState::OutKickoff)
continue;
if(dist > 35.0)
continue;
std::vector<Vector3> passPositions = { sp->getPosition() };
if(mPlayer->getMatch()->getPlayState() != PlayState::OutKickoff) {
Vector3 breakPassPosition = sp->getPosition();
if(MatchHelpers::attacksUp(*p))
breakPassPosition.y += sp->getRunSpeed() * 1.0f;
else
breakPassPosition.y -= sp->getRunSpeed() * 1.0f;
passPositions.push_back(breakPassPosition);
}
for(auto& pos : passPositions) {
if(!MatchHelpers::onPitch(*mPlayer->getMatch(), pos))
continue;
double thisscore = AIHelpers::getPassForwardCoefficient(*p, pos);
float ownGoalDistCoeff = AIHelpers::scaledCoefficient(MatchHelpers::distanceToOwnGoal(*p), 20.0f);
thisscore *= (1.0f - ownGoalDistCoeff);
if(sp->isGoalkeeper())
thisscore *= 0.2f;
if(thisscore > mScore) {
/* if the opponent is farther away from the pass line than maxoppdist,
* ignore the opponent. */
float maxoppdist = Common::clamp(1.0f, (p->getPosition() - pos).length() * 0.2f, 10.0f);
for(auto op : MatchHelpers::getOpposingPlayers(*p)) {
float oppdist = Common::Math::pointToLineDistance(p->getPosition(),
pos,
op->getPosition());
if(oppdist < maxoppdist) {
float decr = riskcoeff * AIHelpers::scaledCoefficient(oppdist, maxoppdist);
decr *= 1.0f + 8.0f *
AIHelpers::scaledCoefficient(MatchHelpers::distanceToOwnGoal(*p, pos), 50.0f);
thisscore -= decr;
}
}
Vector3 thistgt = AIHelpers::getPassKickVector(*mPlayer, pos, Vector3());
thisscore = AIHelpers::checkKickSuccess(*mPlayer, thistgt, thisscore);
if(thisscore > mScore) {
mScore = thisscore;
tgtPlayer = sp.get();
tgt = thistgt;
}
}
}
}
if(mScore >= -1.0f) {
mScore *= mPlayer->getTeam()->getAITacticParameters().PassActionCoefficient;
mAction = boost::shared_ptr<PlayerAction>(new KickBallPA(tgt, tgtPlayer));
}
}
Worker( int id, Common< Package > &common ) :
BaseWorker< S, Package >{ id, common },
_generator{ std::random_device{}() },
_distribution{ 1, common.worldSize() - 1 },
_seed( std::random_device{}() )
{}
bool Message::loopMessage()
{
Common *threadCommon = new Common();
return threadCommon->threadStart() ? true : false;
}
AIShootAction::AIShootAction(const Player* p)
: AIAction(mActionName, p)
{
Vector3 shoottarget = MatchHelpers::oppositeGoalPosition(*p);
Vector3 tgt = shoottarget;
PlayState ps = p->getMatch()->getPlayState();
if(ps == PlayState::OutThrowin ||
ps == PlayState::OutKickoff ||
ps == PlayState::OutGoalkick ||
ps == PlayState::OutIndirectFreekick ||
ps == PlayState::OutDroppedball) {
mScore = -1.0f;
mAction = boost::shared_ptr<PlayerAction>(new KickBallPA(shoottarget, nullptr, true));
return;
}
Vector3 vec(MatchHelpers::oppositePenaltySpotPosition(*p));
vec -= p->getPosition();
if(vec.length() > 32.0f) {
return;
}
if((p->getPosition() - shoottarget).length() < 6.0f) {
mScore = 1.0f;
mAction = boost::shared_ptr<PlayerAction>(new KickBallPA(shoottarget, nullptr, true));
return;
}
const float riskcoeff = mPlayer->getTeam()->getAITacticParameters().ShootCloseCoefficient;
/* controls how far the player might shoot from */
float defaultScore = std::max(0.0f, 1.0f - (vec.length() - 16.0f) *
(0.1f + 0.1f * (1.0f - riskcoeff)));
float maxscore = -1.0f;
const float maxOppDist = 2.0f;
std::vector<Vector3> shoottargets;
shoottargets.push_back(shoottarget);
shoottargets.push_back(Vector3(shoottarget + Vector3(GOAL_WIDTH_2 * 0.75f, 0, 0)));
shoottargets.push_back(Vector3(shoottarget + Vector3(-GOAL_WIDTH_2 * 0.75f, 0, 0)));
for(auto thistgt : shoottargets) {
float thisscore = defaultScore;
for(auto op : MatchHelpers::getOpposingPlayers(*p)) {
float dist = Common::Math::pointToLineDistance(p->getPosition(),
thistgt,
op->getPosition());
if(dist < maxOppDist) {
thisscore -= riskcoeff * AIHelpers::scaledCoefficient(dist, maxOppDist);
if(thisscore <= 0.0) {
thisscore = 0.0f;
break;
}
}
}
thisscore = AIHelpers::checkKickSuccess(*mPlayer, Vector3(thistgt - mPlayer->getPosition()),
thisscore);
if(thisscore > maxscore) {
if((thistgt - p->getPosition()).length() > 15.0f)
thistgt.z = (thistgt - p->getPosition()).length() *
(0.04f + 0.08f * (1.0f - p->getSkills().ShotPower));
maxscore = thisscore;
tgt = thistgt;
}
}
mScore = maxscore;
mScore *= mPlayer->getTeam()->getAITacticParameters().ShootActionCoefficient;
mAction = boost::shared_ptr<PlayerAction>(new KickBallPA(tgt, nullptr, true));
}
static bool isMaster( Common< Package > &common ) {
return common.rank() == Daemon::MainSlave;
}
void gameLoop() {
wParams.mFullscreen = false;
wParams.mHeight = screenHeight;
wParams.mWidth = screenWidth;
wParams.mTitle = "Laboration 2";
wParams.mPosX = 0;
wParams.mPosY = 0;
if (common.init(wParams)) {
common.registerTextureResource("explosion", "image/explosion.png");
EventManager em;
common.setEventProcessor(&em);
Graphics *g = common.getGraphics();
g->setViewport(0, 0, screenWidth, screenHeight);
Renderer2D *renderer = g->createRenderer2D();
float rot = 0.0f;
HiResTimer timer;
timer.restart();
//Set program scale.
AnimationSystem animationSystem(common);
const float TIME_STEP = 1.0 / 50.0f;
float accumulator = 0.0f;
while (gRunning) {
common.getInputState(&inputState);
if (inputState.isDown(Button::BUTTON_ESCAPE)) {
gRunning = 0;
}
common.frame();
timer.tick();
g->clear(Color::Black, true);
accumulator += timer.getDeltaSeconds();
while (accumulator >= TIME_STEP) {
accumulator -= TIME_STEP;
animationSystem.UpdateEmitter(TIME_STEP);
}
renderer->begin(Renderer2D::SPRITE_SORT_DEFERRED, Renderer2D::SPRITE_BLEND_ALPHA);
animationSystem.RenderEmitter(renderer);
rot += timer.getDeltaSeconds() * 0.1f;
renderer->end();
g->present();
}
animationSystem.FreeMem();
}
}