예제 #1
1
 public function index()
 {
     $request = RequestWrapper::$request;
     $target = $request->get('player');
     $target_id = $request->get('player_id');
     if ($target_id) {
         $target_player_obj = Player::find($target_id);
     } else {
         $target_player_obj = Player::findByName($target);
     }
     if ($target_player_obj === null) {
         $template = 'no-player.tpl';
         $viewed_name_for_title = null;
         $parts = array();
     } else {
         $attack_error = 'You must become a ninja first.';
         $clan = Clan::findByMember($target_player_obj);
         $combat_skills = null;
         $display_clan_options = false;
         $items = null;
         $same_clan = false;
         $self = false;
         $targeted_skills = null;
         $template = 'player.tpl';
         $viewed_name_for_title = $target_player_obj->name();
         $viewing_player_obj = Player::find(SessionFactory::getSession()->get('player_id'));
         $kills_today = query_item('SELECT sum(killpoints) FROM levelling_log WHERE _player_id = :player_id AND killsdate = CURRENT_DATE AND killpoints > 0', [':player_id' => $target_player_obj->id()]);
         $rank_spot = query_item('SELECT rank_id FROM rankings WHERE player_id = :player_id limit 1', [':player_id' => $target_player_obj->id()]);
         if ($viewing_player_obj !== null) {
             $viewers_clan = Clan::findByMember($viewing_player_obj);
             $self = $viewing_player_obj->id() === $target_player_obj->id();
             $params = ['required_turns' => 0, 'ignores_stealth' => true];
             $AttackLegal = new AttackLegal($viewing_player_obj, $target_player_obj, $params);
             $AttackLegal->check(false);
             $attack_error = $AttackLegal->getError();
             if (!$attack_error && !$self) {
                 // They're not dead or otherwise unattackable.
                 // Pull the items and some necessary data about them.
                 $inventory = new Inventory($viewing_player_obj);
                 $items = $inventory->counts();
                 $skillDAO = new SkillDAO();
                 if (!$viewing_player_obj->isAdmin()) {
                     $combat_skills = $skillDAO->getSkillsByTypeAndClass($viewing_player_obj->_class_id, 'combat', $viewing_player_obj->level);
                     $targeted_skills = $skillDAO->getSkillsByTypeAndClass($viewing_player_obj->_class_id, 'targeted', $viewing_player_obj->level);
                 } else {
                     $combat_skills = $skillDAO->all('combat');
                     $targeted_skills = $skillDAO->all('targeted');
                 }
             }
             if ($clan && $viewers_clan) {
                 $same_clan = $clan->id == $viewers_clan->id;
                 $display_clan_options = !$self && $same_clan && $viewing_player_obj->isClanLeader();
             }
         }
         $parts = ['viewing_player_obj' => $viewing_player_obj, 'target_player_obj' => $target_player_obj, 'combat_skills' => $combat_skills, 'targeted_skills' => $targeted_skills, 'self' => $self, 'rank_spot' => $rank_spot, 'kills_today' => $kills_today, 'status_list' => Player::getStatusList($target_player_obj->id()), 'clan' => $clan, 'items' => $items, 'account' => Account::findByChar($target_player_obj), 'same_clan' => $same_clan, 'display_clan_options' => $display_clan_options, 'attack_error' => $attack_error];
     }
     $parts['authenticated'] = SessionFactory::getSession()->get('authenticated', false);
     $title = 'Ninja' . ($viewed_name_for_title ? ": {$viewed_name_for_title}" : ' Profile');
     return new StreamedViewResponse($title, $template, $parts, ['quickstat' => 'player']);
 }
예제 #2
0
 /**
  * User command for betting on the coin toss game in the casino
  *
  * @param Container
  * @param bet int The amount of money to bet on the coin toss game
  * @return Response
  *
  * @note
  * If the player bets within ~1% of the maximum bet, they will receive a
  * reward item
  */
 public function bet(Container $p_dependencies)
 {
     $player = $p_dependencies['current_player'];
     if (!$player) {
         return new RedirectResponse('/casino/?error=' . rawurlencode('Become a ninja first!'));
     }
     $bet = intval(RequestWrapper::getPostOrGet('bet'));
     $pageParts = ['reminder-max-bet'];
     if ($bet < 0) {
         $pageParts = ['result-cheat'];
         $player->harm(self::CHEAT_DMG);
     } else {
         if ($bet > $player->gold) {
             $pageParts = ['result-no-gold'];
         } else {
             if ($bet > 0 && $bet <= self::MAX_BET) {
                 if (rand(0, 1) === 1) {
                     $pageParts = ['result-win'];
                     $player->setGold($player->gold + $bet);
                     if ($bet >= round(self::MAX_BET * 0.99)) {
                         // within about 1% of the max bet & you win, you get a reward item.
                         $inventory = new Inventory($player);
                         $inventory->add(self::REWARD, 1);
                     }
                 } else {
                     $player->setGold($player->gold - $bet);
                     $pageParts = ['result-lose'];
                 }
             }
         }
     }
     $player->save();
     return $this->render(['pageParts' => $pageParts, 'player' => $player]);
 }
예제 #3
0
 /**
  * Action to request the Dim Mak form AND execute the purchase
  *
  * @todo split form request (GET) and purchase (POST) into separate funcs
  * @param Container
  * @return Response
  */
 public function buyDimMak(Container $p_dependencies)
 {
     if ($p_dependencies['session']->get('authenticated', false)) {
         $player = $p_dependencies['current_player'];
         $showMonks = false;
         $parts = [];
         if (RequestWrapper::$request && RequestWrapper::$request->isMethod('POST')) {
             $error = $this->dimMakReqs($player, self::DIM_MAK_COST);
             if (!$error) {
                 $player->changeTurns(-1 * self::DIM_MAK_COST);
                 $inventory = new Inventory($player);
                 $inventory->add('dimmak', 1);
                 $parts['pageParts'] = ['success-dim-mak'];
                 $showMonks = true;
                 $player->save();
             } else {
                 $parts['error'] = $error;
             }
         } else {
             $parts['pageParts'] = ['form-dim-mak'];
             $parts['dim_mak_cost'] = self::DIM_MAK_COST;
         }
         return $this->render($parts, $player, $showMonks);
     } else {
         return $this->accessDenied();
     }
 }
예제 #4
0
 public function testShouldObtainInventory()
 {
     $inventory = new Inventory($this->char);
     $inventory->add('shuriken', 10);
     $shurikens = null;
     foreach ($inventory as $itemz) {
         if ($itemz['item_internal_name'] === 'shuriken') {
             $shurikens = $itemz;
         }
     }
     $this->assertEquals($shurikens['count'], 10);
     $this->assertEquals($shurikens['item_internal_name'], 'shuriken');
 }
예제 #5
0
 /**
  * Command for current user to purchase a quantity of a specific item
  *
  * @param quantity int The quantity of the item to purchase
  * @param item string The identity of the item to purchase
  * @return Array
  */
 public function buy()
 {
     $request = RequestWrapper::$request;
     $in_quantity = $request->get('quantity');
     $in_item = $request->get('item');
     $player = Player::findPlayable($this->getAccountId());
     $gold = $player ? $player->gold : null;
     $current_item_cost = 0;
     $no_funny_business = false;
     $no_such_item = false;
     $item = Item::findByIdentity($in_item);
     $quantity = max(Filter::toNonNegativeInt($in_quantity), self::DEFAULT_QUANTITY);
     $item_text = null;
     $valid = false;
     if (!$item instanceof Item) {
         $no_such_item = true;
     } else {
         $item_text = $quantity > 1 ? $item->getPluralName() : $item->getName();
         $purchase_order = new PurchaseOrder();
         // Determine the quantity from input or as a fallback, default of 1.
         $purchase_order->quantity = $quantity;
         $purchase_order->item = $item;
         $current_item_cost = $this->calculatePrice($purchase_order);
         if (!$player) {
             $no_funny_business = true;
         } elseif (!$purchase_order->item || $purchase_order->quantity < 1) {
             $no_such_item = true;
         } else {
             if ($gold >= $current_item_cost) {
                 // Has enough gold.
                 try {
                     $inventory = new Inventory($player);
                     $inventory->add($purchase_order->item->identity(), $purchase_order->quantity);
                     $player->setGold($player->gold - $current_item_cost);
                     $player->save();
                     $valid = true;
                 } catch (\Exception $e) {
                     $invalid_item = $e->getMessage();
                     error_log('Invalid Item attempted :' . $invalid_item);
                     $no_funny_business = true;
                 }
             }
         }
     }
     $parts = array('current_item_cost' => $current_item_cost, 'quantity' => $quantity, 'item_text' => $item_text, 'no_funny_business' => $no_funny_business, 'no_such_item' => $no_such_item, 'valid' => $valid, 'view_part' => 'buy');
     return $this->render($parts);
 }
예제 #6
0
 public function testShopAllowsPurchasingOfMultipleItems()
 {
     $pc = Player::findPlayable($this->account->id());
     $pc->gold = $pc->gold + 9999;
     $pc->save();
     $request = new Request([], ['quantity' => 7, 'item' => 'shuriken']);
     RequestWrapper::inject($request);
     $shop = new ShopController();
     $response = $shop->buy();
     $this->assertNotEmpty($response);
     $reflection = new \ReflectionProperty(get_class($response), 'data');
     $reflection->setAccessible(true);
     $response_data = $reflection->getValue($response);
     $this->assertTrue($response_data['valid']);
     $inv = new Inventory($pc);
     $this->assertEquals(7, $inv->amount('shuriken'));
 }
예제 #7
0
 /**
  * Normal attack on a single thief.
  */
 private function attackNormalThief(Player $player)
 {
     $damage = rand(0, 35);
     // Damage done
     $gold = 0;
     if ($victory = $player->harm($damage)) {
         $gold = rand(0, 40);
         // Gold in question
         if ($damage > 30) {
             // Steal gold
             $player->setGold(max(0, $player->gold - $gold));
         } else {
             if ($damage < 30) {
                 // award gold and item
                 $player->setGold($player->gold + $gold);
                 $inventory = new Inventory($player);
                 $inventory->add('shuriken', 1);
             }
         }
     }
     $player->save();
     return ['npc.thief.tpl', ['attack' => $damage, 'gold' => $gold, 'victory' => $victory]];
 }
예제 #8
0
 /**
  * Use, the skills_mod equivalent
  *
  * @note Test with urls like:
  * http://nw.local/skill/use/Fire%20Bolt/10
  * http://nw.local/skill/self_use/Unstealth/
  * http://nw.local/skill/self_use/Heal/
  */
 public function useSkill($self_use = false)
 {
     // Template vars.
     $display_sight_table = $generic_skill_result_message = $generic_state_change = $killed_target = $loot = $added_bounty = $bounty = $suicided = $destealthed = null;
     $error = null;
     $char_id = SessionFactory::getSession()->get('player_id');
     $player = Player::find($char_id);
     $path = RequestWrapper::getPathInfo();
     $slugs = $this->parseSlugs($path);
     // (fullpath0) /skill1/use2/Fire%20Bolt3/tchalvak4/(beagle5/)
     $act = isset($slugs[3]) ? $slugs[3] : null;
     $target = isset($slugs[4]) ? $slugs[4] : null;
     $target2 = isset($slugs[5]) ? $slugs[5] : null;
     if (!Filter::toNonNegativeInt($target)) {
         if ($self_use) {
             $target = $char_id;
         } else {
             if ($target !== null) {
                 $targetObj = Player::findByName($target);
                 $target = $targetObj ? $targetObj->id() : null;
             } else {
                 $target = null;
             }
         }
     }
     if ($target2 && !Filter::toNonNegativeInt($target2)) {
         $target2Obj = Player::findByName($target2);
         $target2 = $target2Obj ? $target2Obj->id() : null;
     }
     $skillListObj = new Skill();
     // *** Before level-based addition.
     $turn_cost = $skillListObj->getTurnCost(strtolower($act));
     $ignores_stealth = $skillListObj->getIgnoreStealth($act);
     $self_usable = $skillListObj->getSelfUse($act);
     $use_on_target = $skillListObj->getUsableOnTarget($act);
     $ki_cost = 0;
     // Ki taken during use.
     $reuse = true;
     // Able to reuse the skill.
     $today = date("F j, Y, g:i a");
     // Check whether the user actually has the needed skill.
     $has_skill = $skillListObj->hasSkill($act, $player);
     assert($turn_cost >= 0);
     if ($self_use) {
         // Use the skill on himself.
         $return_to_target = false;
         $target = $player;
         $target_id = null;
     } else {
         if ($target != '' && $target != $player->player_id) {
             $target = Player::find($target);
             $target_id = $target->id();
             $return_to_target = true;
         } else {
             // For target that doesn't exist, e.g. http://nw.local/skill/use/Sight/zigzlklkj
             error_log('Info: Attempt to use a skill on a target that did not exist.');
             return new RedirectResponse(WEB_ROOT . 'skill/?error=' . rawurlencode('Invalid target for skill [' . rawurlencode($act) . '].'));
         }
     }
     $covert = false;
     $victim_alive = true;
     $attacker_id = $player->name();
     $attacker_char_id = $player->id();
     $starting_turns = $player->turns;
     $level_check = $player->level - $target->level;
     if ($player->hasStatus(STEALTH)) {
         $attacker_id = 'A Stealthed Ninja';
     }
     $use_attack_legal = true;
     if ($act == 'Clone Kill' || $act == 'Harmonize') {
         $has_skill = true;
         $use_attack_legal = false;
         $attack_allowed = true;
         $attack_error = null;
         $covert = true;
     } else {
         // *** Checks the skill use legality, as long as the target isn't self.
         $params = ['required_turns' => $turn_cost, 'ignores_stealth' => $ignores_stealth, 'self_use' => $self_use];
         $AttackLegal = new AttackLegal($player, $target, $params);
         $update_timer = isset($this->update_timer) ? $this->update_timer : true;
         $attack_allowed = $AttackLegal->check($update_timer);
         $attack_error = $AttackLegal->getError();
     }
     if (!$attack_error) {
         // Only bother to check for other errors if there aren't some already.
         if (!$has_skill || $act == '') {
             // Set the attack error to display that that skill wasn't available.
             $attack_error = 'You do not have the requested skill.';
         } elseif ($starting_turns < $turn_cost) {
             $turn_cost = 0;
             $attack_error = "You do not have enough turns to use {$act}.";
         }
     }
     if (!$attack_error) {
         // Nothing to prevent the attack from happening.
         // Initial attack conditions are alright.
         $result = '';
         if ($act == 'Sight') {
             $covert = true;
             $sight_data = $this->pullSightData($target);
             $display_sight_table = true;
         } elseif ($act == 'Steal') {
             $covert = true;
             $gold_decrease = min($target->gold, rand(5, 50));
             $player->setGold($player->gold + $gold_decrease);
             $player->save();
             $target->setGold($target->gold - $gold_decrease);
             $target->save();
             $msg = "{$attacker_id} stole {$gold_decrease} gold from you.";
             Event::create($attacker_char_id, $target->id(), $msg);
             $generic_skill_result_message = "You have stolen {$gold_decrease} gold from __TARGET__!";
         } else {
             if ($act == 'Unstealth') {
                 $state = 'unstealthed';
                 if ($target->hasStatus(STEALTH)) {
                     $target->subtractStatus(STEALTH);
                     $generic_state_change = "You are now {$state}.";
                 } else {
                     $turn_cost = 0;
                     $generic_state_change = "__TARGET__ is already {$state}.";
                 }
             } else {
                 if ($act == 'Stealth') {
                     $covert = true;
                     $state = 'stealthed';
                     if (!$target->hasStatus(STEALTH)) {
                         $target->addStatus(STEALTH);
                         $target->subtractStatus(STALKING);
                         $generic_state_change = "__TARGET__ is now {$state}.";
                     } else {
                         $turn_cost = 0;
                         $generic_state_change = "__TARGET__ is already {$state}.";
                     }
                 } else {
                     if ($act == 'Stalk') {
                         $state = 'stalking';
                         if (!$target->hasStatus(STALKING)) {
                             $target->addStatus(STALKING);
                             $target->subtractStatus(STEALTH);
                             $generic_state_change = "__TARGET__ is now {$state}.";
                         } else {
                             $turn_cost = 0;
                             $generic_state_change = "__TARGET__ is already {$state}.";
                         }
                     } else {
                         if ($act == 'Kampo') {
                             $covert = true;
                             // *** Get Special Items From Inventory ***
                             $user_id = $player->id();
                             $root_item_type = 7;
                             $itemCount = query_item('SELECT sum(amount) AS c FROM inventory WHERE owner = :owner AND item_type = :type GROUP BY item_type', [':owner' => $user_id, ':type' => $root_item_type]);
                             $turn_cost = min($itemCount, $starting_turns - 1, 2);
                             // Costs 1 or two depending on the number of items.
                             if ($turn_cost && $itemCount > 0) {
                                 // *** If special item count > 0 ***
                                 $inventory = new Inventory($player);
                                 $inventory->remove('ginsengroot', $itemCount);
                                 $inventory->add('tigersalve', $itemCount);
                                 $generic_skill_result_message = 'With intense focus you grind the ' . $itemCount . ' roots into potent formulas.';
                             } else {
                                 // *** no special items, give error message ***
                                 $turn_cost = 0;
                                 $generic_skill_result_message = 'You do not have the necessary ginsengroots or energy to create any Kampo formulas.';
                             }
                         } else {
                             if ($act == 'Poison Touch') {
                                 $covert = true;
                                 $target->addStatus(POISON);
                                 $target->addStatus(WEAKENED);
                                 // Weakness kills strength.
                                 $target_damage = rand(self::MIN_POISON_TOUCH, $this->maxPoisonTouch());
                                 $victim_alive = $target->harm($target_damage);
                                 $generic_state_change = "__TARGET__ has been poisoned!";
                                 $generic_skill_result_message = "__TARGET__ has taken {$target_damage} damage!";
                                 $msg = "You have been poisoned by {$attacker_id}";
                                 Event::create($attacker_char_id, $target->id(), $msg);
                             } elseif ($act == 'Fire Bolt') {
                                 $target_damage = $this->fireBoltBaseDamage($player) + rand(1, $this->fireBoltMaxDamage($player));
                                 $generic_skill_result_message = "__TARGET__ has taken {$target_damage} damage!";
                                 $victim_alive = $target->harm($target_damage);
                                 $msg = "You have had fire bolt cast on you by " . $player->name();
                                 Event::create($player->id(), $target->id(), $msg);
                             } else {
                                 if ($act == 'Heal' || $act == 'Harmonize') {
                                     // This is the starting template for self-use commands, eventually it'll be all refactored.
                                     $harmonize = false;
                                     if ($act == 'Harmonize') {
                                         $harmonize = true;
                                     }
                                     $hurt = $target->is_hurt_by();
                                     // Check how much the TARGET is hurt (not the originator, necessarily).
                                     // Check that the target is not already status healing.
                                     if ($target->hasStatus(HEALING) && !$player->isAdmin()) {
                                         $turn_cost = 0;
                                         $generic_state_change = '__TARGET__ is already under a healing aura.';
                                     } elseif ($hurt < 1) {
                                         $turn_cost = 0;
                                         $generic_skill_result_message = '__TARGET__ is already fully healed.';
                                     } else {
                                         if (!$harmonize) {
                                             $original_health = $target->health;
                                             $heal_points = $player->getStamina() + 1;
                                             $new_health = $target->heal($heal_points);
                                             // Won't heal more than possible
                                             $healed_by = $new_health - $original_health;
                                         } else {
                                             $start_health = $player->health;
                                             // Harmonize those chakra!
                                             $player = $this->harmonizeChakra($player);
                                             $healed_by = $player->health - $start_health;
                                             $ki_cost = $healed_by;
                                         }
                                         $target->addStatus(HEALING);
                                         $generic_skill_result_message = "__TARGET__ healed by {$healed_by} to " . $target->health . ".";
                                         if ($target->id() != $player->id()) {
                                             Event::create($attacker_char_id, $target->id(), "You have been healed by {$attacker_id} for {$healed_by}.");
                                         }
                                     }
                                 } else {
                                     if ($act == 'Ice Bolt') {
                                         if ($target->hasStatus(SLOW)) {
                                             $turn_cost = 0;
                                             $generic_skill_result_message = '__TARGET__ is already iced.';
                                         } else {
                                             if ($target->turns >= 10) {
                                                 $turns_decrease = rand(1, 5);
                                                 $target->turns = $target->turns - $turns_decrease;
                                                 // Changed ice bolt to kill stealth.
                                                 $target->subtractStatus(STEALTH);
                                                 $target->subtractStatus(STALKING);
                                                 $target->addStatus(SLOW);
                                                 $msg = "Ice bolt cast on you by {$attacker_id}, your turns have been reduced by {$turns_decrease}.";
                                                 Event::create($attacker_char_id, $target->id(), $msg);
                                                 $generic_skill_result_message = "__TARGET__'s turns reduced by {$turns_decrease}!";
                                             } else {
                                                 $turn_cost = 0;
                                                 $generic_skill_result_message = "__TARGET__ does not have enough turns for you to take.";
                                             }
                                         }
                                     } else {
                                         if ($act == 'Cold Steal') {
                                             if ($target->hasStatus(SLOW)) {
                                                 $turn_cost = 0;
                                                 $generic_skill_result_message = '__TARGET__ is already iced.';
                                             } else {
                                                 $critical_failure = rand(1, 100);
                                                 if ($critical_failure > 7) {
                                                     // *** If the critical failure rate wasn't hit.
                                                     if ($target->turns >= 10) {
                                                         $turns_diff = rand(2, 7);
                                                         $target->turns = $target->turns - $turns_diff;
                                                         $player->turns = $player->turns + $turns_diff;
                                                         // Stolen
                                                         $target->addStatus(SLOW);
                                                         $msg = "You have had Cold Steal cast on you for {$turns_diff} by {$attacker_id}";
                                                         Event::create($attacker_char_id, $target->id(), $msg);
                                                         $generic_skill_result_message = "You cast Cold Steal on __TARGET__ and take {$turns_diff} turns.";
                                                     } else {
                                                         $turn_cost = 0;
                                                         $generic_skill_result_message = '__TARGET__ did not have enough turns to give you.';
                                                     }
                                                 } else {
                                                     // *** CRITICAL FAILURE !!
                                                     $player->addStatus(FROZEN);
                                                     $unfreeze_time = date('F j, Y, g:i a', mktime(date('G') + 1, 0, 0, date('m'), date('d'), date('Y')));
                                                     $failure_msg = "You have experienced a critical failure while using Cold Steal. You will be unfrozen on {$unfreeze_time}";
                                                     Event::create((int) 0, $player->id(), $failure_msg);
                                                     $generic_skill_result_message = "Cold Steal has backfired! You are frozen until {$unfreeze_time}!";
                                                 }
                                             }
                                         } else {
                                             if ($act == 'Clone Kill') {
                                                 // Obliterates the turns and the health of similar accounts that get clone killed.
                                                 $reuse = false;
                                                 // Don't give a reuse link.
                                                 $clone1 = Player::findByName($target);
                                                 $clone2 = Player::findByName($target2);
                                                 if (!$clone1 || !$clone2) {
                                                     $not_a_ninja = $target;
                                                     if (!$clone2) {
                                                         $not_a_ninja = $target2;
                                                     }
                                                     $generic_skill_result_message = "There is no such ninja as {$not_a_ninja}.";
                                                 } elseif ($clone1->id() == $clone2->id()) {
                                                     $generic_skill_result_message = '__TARGET__ is just the same ninja, so not the same thing as a clone at all.';
                                                 } elseif ($clone1->id() == $char_id || $clone2->id() == $char_id) {
                                                     $generic_skill_result_message = 'You cannot clone kill yourself.';
                                                 } else {
                                                     // The two potential clones will be obliterated immediately if the criteria are met in CloneKill.
                                                     $kill_or_fail = CloneKill::kill($player, $clone1, $clone2);
                                                     if ($kill_or_fail !== false) {
                                                         $generic_skill_result_message = $kill_or_fail;
                                                     } else {
                                                         $generic_skill_result_message = "Those two ninja don't seem to be clones.";
                                                     }
                                                 }
                                             }
                                         }
                                     }
                                 }
                             }
                         }
                     }
                 }
             }
         }
         // ************************** Section applies to all skills ******************************
         if (!$victim_alive) {
             // Someone died.
             if ($target->player_id == $player->player_id) {
                 // Attacker killed themself.
                 $loot = 0;
                 $suicided = true;
             } else {
                 // Attacker killed someone else.
                 $killed_target = true;
                 $gold_mod = 0.15;
                 $loot = floor($gold_mod * $target->gold);
                 $player->setGold($player->gold + $loot);
                 $target->setGold($target->gold - $loot);
                 $player->addKills(1);
                 $added_bounty = floor($level_check / 5);
                 if ($added_bounty > 0) {
                     $player->setBounty($player->bounty + $added_bounty * 25);
                 } else {
                     if ($target->bounty > 0 && $target->id() !== $player->id()) {
                         // No suicide bounty, No bounty when your bounty getting ++ed.
                         $player->setGold($player->gold + $target->bounty);
                         // Reward the bounty
                         $target->setBounty(0);
                         // Wipe the bounty
                     }
                 }
                 $target_message = "{$attacker_id} has killed you with {$act} and taken {$loot} gold.";
                 Event::create($attacker_char_id, $target->id(), $target_message);
                 $attacker_message = "You have killed {$target} with {$act} and taken {$loot} gold.";
                 Event::create($target->id(), $player->id(), $attacker_message);
             }
         }
         if (!$covert && $player->hasStatus(STEALTH)) {
             $player->subtractStatus(STEALTH);
             $destealthed = true;
         }
         $target->save();
     }
     // End of the skill use SUCCESS block.
     $player->turns = $player->turns - max(0, $turn_cost);
     // Take the skill use cost.
     $player->save();
     $ending_turns = $player->turns;
     $target_ending_health = $target->health;
     $target_name = $target->name();
     $parts = get_defined_vars();
     $options = ['quickstat' => 'player'];
     return new StreamedViewResponse('Skill Effect', 'skills_mod.tpl', $parts, $options);
 }
예제 #9
0
 /**
  * @return void
  */
 private function transferOwnership(Player $giver, Player $recipient, Item $item, $quantity)
 {
     $giver_inventory = new Inventory($giver);
     $taker_inventory = new Inventory($recipient);
     $taker_inventory->add($item->identity(), $quantity);
     $giver_inventory->remove($item->identity(), $quantity);
 }