/**
* Test for postAnswer
*/
public function testPostAnswer()
{
$user1 = factory(App\Models\User::class)->create();
$user2 = factory(App\Models\User::class)->create();
// create two battles
$br = new BattleRequest();
$br->challenger_id = $user1->id;
$br->challenged_id = $user2->id;
$br->save();
// execute postAnswer()
$this->actingAs($user1)->post('/request/' . $br->id, ['accepted' == TRUE]);
$oP = OpenBattle::find($br->challenger_id);
//checking the output
$this->assertNotNull($oP);
$this->assertEquals($user1->id, $oP->rapper1_id);
$this->assertEquals($user2->id, $oP->rapper2_id);
}
/**
* Insertion test
*
* @return void
*/
public function testInsert()
{
$user1 = factory(App\Models\User::class)->create();
$user2 = factory(App\Models\User::class)->create();
$battleRequest = new BattleRequest();
$battleRequest->challenger_id = $user1->id;
$battleRequest->challenged_id = $user2->id;
$battleRequest->save();
// is request in database?
$this->seeInDatabase('battle_requests', ['challenger_id' => $user1->id, 'challenged_id' => $user2->id]);
// can challenger and challenged user be retrieved?
$this->assertNotNull($battleRequest->challenger()->get()->values()->keyBy('id')->get($user1->id));
$this->assertNotNull($battleRequest->challenged()->get()->values()->keyBy('id')->get($user2->id));
// can users retrieve their open battles?
$this->assertNotNull($user1->BattleRequestsChallenger()->get()->values()->keyBy('id')->get($battleRequest->id));
$this->assertNotNull($user2->BattleRequestsChallenged()->get()->values()->keyBy('id')->get($battleRequest->id));
}
/**
* Test for battleRequests()
*
* @return void
*/
public function testBattleRequests()
{
$user1 = factory(App\Models\User::class)->create();
$user2 = factory(App\Models\User::class)->create();
$user3 = factory(App\Models\User::class)->create();
$user4 = factory(App\Models\User::class)->create();
$battleRequest1 = new BattleRequest();
$battleRequest1->challenger_id = $user1->id;
$battleRequest1->challenged_id = $user2->id;
$battleRequest1->save();
$battleRequest2 = new BattleRequest();
$battleRequest2->challenger_id = $user2->id;
$battleRequest2->challenged_id = $user3->id;
$battleRequest2->save();
$battleRequest3 = new BattleRequest();
$battleRequest3->challenger_id = $user3->id;
$battleRequest3->challenged_id = $user1->id;
$battleRequest3->save();
// get battle requests of user2
$battleRequests = $user2->battleRequests()->lists('id')->toArray();
$this->assertCount(2, $battleRequests);
$this->assertContains($battleRequest1->id, $battleRequests);
$this->assertContains($battleRequest2->id, $battleRequests);
$this->assertNotContains($battleRequest3->id, $battleRequests);
// get battle requests, where user2 is challenger
$battleRequestsChallenger = $user2->battleRequestsChallenger()->lists('id')->toArray();
$this->assertCount(1, $battleRequestsChallenger);
$this->assertContains($battleRequest2->id, $battleRequestsChallenger);
// get battle requests, where user2 is challenged
$battleRequestsChallenged = $user2->battleRequestsChallenged()->lists('id')->toArray();
$this->assertCount(1, $battleRequestsChallenged);
$this->assertContains($battleRequest1->id, $battleRequestsChallenged);
// get battle requests of user 4 (should be none)
$this->assertCount(0, $user4->battleRequests()->lists('id')->toArray());
// tests for hasBattleRequestAgainst()
$this->assertTrue($user1->hasBattleRequestAgainst($user2));
$this->assertTrue($user1->hasBattleRequestAgainst($user3));
$this->assertTrue($user2->hasBattleRequestAgainst($user1));
$this->assertTrue($user2->hasBattleRequestAgainst($user3));
$this->assertFalse($user1->hasBattleRequestAgainst($user4));
$this->assertFalse($user4->hasBattleRequestAgainst($user3));
// tests for scopeNoBattleRequestsAgainst()
$nbra1 = $user1->noBattleRequestsAgainst($user4)->lists('id')->toArray();
$this->assertContains($user4->id, $nbra1);
$nbra4 = $user4->noBattleRequestsAgainst($user4)->lists('id')->toArray();
$this->assertContains($user1->id, $nbra4);
$this->assertContains($user2->id, $nbra4);
$this->assertContains($user3->id, $nbra4);
}
/**
* Find a random opponent for the authenticated user based on rating.
*
* @return \Illuminate\Http\JsonResponse
*/
public function getRandomOpponent()
{
$user = Auth::user();
if (is_null($user)) {
return response('Unauthorized', 401);
}
// Number of possible opponents = Number of rappers - 1 (Authenticated user)
// - Number of open battles of authenticated user
// - Number of battle requests of authenticated user
$possibleOpponentCount = User::rapper()->count() - 1 - $user->openBattles()->count() - $user->battleRequests()->count();
$opponent = null;
// This is faster because there are no unecessary iterations.
if ($possibleOpponentCount == 1) {
// There is only one possible opponent.
$opponent = User::validOpponentFor($user)->first();
} elseif ($possibleOpponentCount > 1) {
// Increase the search range exponentially to make sure an opponent is found.
$exponentialBase = 2;
$rating = $user->rating;
$validOpponents = User::validOpponentFor($user);
$validOpponentsCnt = $validOpponents->count();
if (!$validOpponents->get()->isEmpty()) {
for ($i = 0; is_null($opponent); $i++) {
$range = pow($exponentialBase, $i);
$minRating = $rating - $range;
$maxRating = $rating + $range;
$possibleOpponents = $validOpponents->ratedBetween($minRating, $maxRating)->get();
if (!$possibleOpponents->isEmpty()) {
$opponent = $possibleOpponents->random();
// Log for later optimizing
Log::info('Random opponent found.', ['possible opponents' => $possibleOpponentCount, 'exponential base' => $exponentialBase, 'iterations' => $i]);
}
}
}
}
if (!is_null($opponent)) {
$battleRequest = new BattleRequest();
$battleRequest->challenger()->associate($user);
$battleRequest->challenged()->associate($opponent);
$battleRequest->save();
$opponent = $opponent->profilePreview();
}
return response()->json(['opponent' => $opponent]);
}
/**
* Run the database seeds.
*
* @return void
*/
public function run()
{
Model::unguard();
// config
$usercnt = 20;
$userRappercnt = 20;
$battlecnt = 20;
$battleRequestcnt = rand($userRappercnt / 4, $userRappercnt / 2);
// max $userRappercnt / 2
$openBattlecnt = rand($userRappercnt / 4, $userRappercnt / 2);
// max $userRappercnt / 2
// create users
$users = factory(App\Models\User::class, $usercnt)->create();
// rapper and non-rapper
$usersRapper = factory(App\Models\User::class, 'rapper', $userRappercnt)->create();
// rapper only
//----------------------------------------------
// create battles
for ($i = 0; $i < $battlecnt; $i++) {
$battle = new Battle();
// get first rapper
$battle->rapper1_id = $usersRapper->random()->id;
// get second rapper != first rapper
do {
$battle->rapper2_id = $usersRapper->random()->id;
} while ($battle->rapper1_id == $battle->rapper2_id);
$battle->save();
//-----------------------------------------
// create votes
// create list of all created users
$usersAll = $users->keyBy('id')->merge($usersRapper->keyBy('id'));
$usersAll->shuffle();
$userVotescnt = rand(0, $usersAll->count());
for ($j = 0; $j < $userVotescnt; $j++) {
$vote = new Vote();
$vote->user_id = $usersAll->get($j)->id;
$vote->battle_id = $battle->id;
$vote->rapper_number = rand(0, 1);
$vote->save();
// update vote counter
if ($vote->rapper_number == 0) {
$battle->votes_rapper1++;
} else {
$battle->votes_rapper2++;
}
}
// save vote count in battle
$battle->save();
$battle->rapper1->updateRating();
$battle->rapper2->updateRating();
}
//----------------------------------------------
// create battle_requests
for ($i = 0; $i < $battleRequestcnt * 2; $i += 2) {
$battleRequest = new BattleRequest();
$battleRequest->challenger_id = $usersRapper->get($i)->id;
$battleRequest->challenged_id = $usersRapper->get($i + 1)->id;
$battleRequest->save();
}
//----------------------------------------------
// create open battles
$usersRapper->shuffle();
for ($i = 0; $i < $openBattlecnt * 2; $i += 2) {
$openBattle = new OpenBattle();
$openBattle->rapper1_id = $usersRapper->get($i)->id;
$openBattle->rapper2_id = $usersRapper->get($i + 1)->id;
$openBattle->phase = rand(1, 2);
// TODO: how many phases?
$openBattle->beat1_id = rand(0, 2);
$openBattle->beat2_id = rand(0, 2);
$openBattle->save();
}
Model::reguard();
}
/**
* Checks whether a user has a battle request agains $user
*/
public function hasBattleRequestAgainst(User $user)
{
// possibly naive solution, other one had really ugly bugs
$cnt1 = BattleRequest::where('challenger_id', $this->id)->where('challenged_id', $user->id)->count();
$cnt2 = BattleRequest::where('challenged_id', $this->id)->where('challenger_id', $user->id)->count();
return $cnt1 > 0 || $cnt2 > 0;
}
