mirror of
https://github.com/pmmp/PocketMine-MP.git
synced 2025-08-30 15:01:19 +00:00
297 lines
10 KiB
PHP
297 lines
10 KiB
PHP
<?php
|
|
|
|
/*
|
|
*
|
|
* ____ _ _ __ __ _ __ __ ____
|
|
* | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \
|
|
* | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) |
|
|
* | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/
|
|
* |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_|
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU Lesser General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* @author PocketMine Team
|
|
* @link http://www.pocketmine.net/
|
|
*
|
|
*
|
|
*/
|
|
|
|
declare(strict_types=1);
|
|
|
|
namespace pocketmine\inventory\transaction;
|
|
|
|
use pocketmine\crafting\CraftingManager;
|
|
use pocketmine\crafting\CraftingRecipe;
|
|
use pocketmine\crafting\RecipeIngredient;
|
|
use pocketmine\event\inventory\CraftItemEvent;
|
|
use pocketmine\item\Item;
|
|
use pocketmine\player\Player;
|
|
use pocketmine\utils\Utils;
|
|
use function array_fill_keys;
|
|
use function array_keys;
|
|
use function array_pop;
|
|
use function count;
|
|
use function intdiv;
|
|
use function min;
|
|
use function uasort;
|
|
|
|
/**
|
|
* This transaction type is specialized for crafting validation. It shares most of the same semantics of the base
|
|
* inventory transaction type, but the requirement for validity is slightly different.
|
|
*
|
|
* It is expected that the actions in this transaction type will produce an **unbalanced result**, i.e. some inputs won't
|
|
* have corresponding outputs, and vice versa. The reason why is because the unmatched inputs are recipe inputs, and
|
|
* the unmatched outputs are recipe results.
|
|
*
|
|
* Therefore, the validity requirement is that the imbalance of the transaction should match the expected inputs and
|
|
* outputs of a registered crafting recipe.
|
|
*
|
|
* This transaction allows multiple repetitions of the same recipe to be crafted in a single batch. In the case of batch
|
|
* crafting, the number of unmatched inputs and outputs must be exactly divisible by the expected recipe ingredients and
|
|
* results, with no remainder. Any leftovers are expected to be emitted back to the crafting grid.
|
|
*/
|
|
class CraftingTransaction extends InventoryTransaction{
|
|
protected ?CraftingRecipe $recipe = null;
|
|
protected ?int $repetitions = null;
|
|
|
|
/**
|
|
* @var Item[]
|
|
* @phpstan-var list<Item>
|
|
*/
|
|
protected array $inputs = [];
|
|
/**
|
|
* @var Item[]
|
|
* @phpstan-var list<Item>
|
|
*/
|
|
protected array $outputs = [];
|
|
|
|
private CraftingManager $craftingManager;
|
|
|
|
public function __construct(Player $source, CraftingManager $craftingManager, array $actions = [], ?CraftingRecipe $recipe = null, ?int $repetitions = null){
|
|
parent::__construct($source, $actions);
|
|
$this->craftingManager = $craftingManager;
|
|
$this->recipe = $recipe;
|
|
$this->repetitions = $repetitions;
|
|
}
|
|
|
|
/**
|
|
* @param Item[] $providedItems
|
|
* @return Item[]
|
|
*
|
|
* @phpstan-param list<Item> $providedItems
|
|
* @phpstan-return list<Item>
|
|
*/
|
|
private static function packItems(array $providedItems) : array{
|
|
$packedProvidedItems = [];
|
|
while(count($providedItems) > 0){
|
|
$item = array_pop($providedItems);
|
|
foreach($providedItems as $k => $otherItem){
|
|
if($item->canStackWith($otherItem)){
|
|
$item->setCount($item->getCount() + $otherItem->getCount());
|
|
unset($providedItems[$k]);
|
|
}
|
|
}
|
|
$packedProvidedItems[] = $item;
|
|
}
|
|
|
|
return $packedProvidedItems;
|
|
}
|
|
|
|
/**
|
|
* @param Item[] $providedItems
|
|
* @param RecipeIngredient[] $recipeIngredients
|
|
*
|
|
* @phpstan-param list<Item> $providedItems
|
|
* @phpstan-param list<RecipeIngredient> $recipeIngredients
|
|
*/
|
|
public static function matchIngredients(array $providedItems, array $recipeIngredients, int $expectedIterations) : void{
|
|
if(count($recipeIngredients) === 0){
|
|
throw new TransactionValidationException("No recipe ingredients given");
|
|
}
|
|
if(count($providedItems) === 0){
|
|
throw new TransactionValidationException("No transaction items given");
|
|
}
|
|
|
|
$packedProvidedItems = self::packItems(Utils::cloneObjectArray($providedItems));
|
|
$packedProvidedItemMatches = array_fill_keys(array_keys($packedProvidedItems), 0);
|
|
|
|
$recipeIngredientMatches = [];
|
|
|
|
foreach($recipeIngredients as $ingredientIndex => $recipeIngredient){
|
|
$acceptedItems = [];
|
|
foreach($packedProvidedItems as $itemIndex => $packedItem){
|
|
if($recipeIngredient->accepts($packedItem)){
|
|
$packedProvidedItemMatches[$itemIndex]++;
|
|
$acceptedItems[$itemIndex] = $itemIndex;
|
|
}
|
|
}
|
|
|
|
if(count($acceptedItems) === 0){
|
|
throw new TransactionValidationException("No provided items satisfy ingredient requirement $recipeIngredient");
|
|
}
|
|
|
|
$recipeIngredientMatches[$ingredientIndex] = $acceptedItems;
|
|
}
|
|
|
|
foreach($packedProvidedItemMatches as $itemIndex => $itemMatchCount){
|
|
if($itemMatchCount === 0){
|
|
$item = $packedProvidedItems[$itemIndex];
|
|
throw new TransactionValidationException("Provided item $item is not accepted by any recipe ingredient");
|
|
}
|
|
}
|
|
|
|
//Most picky ingredients first - avoid picky ingredient getting their items stolen by wildcard ingredients
|
|
//TODO: this is still insufficient when multiple wildcard ingredients have overlaps, but we don't (yet) have to
|
|
//worry about those.
|
|
uasort($recipeIngredientMatches, fn(array $a, array $b) => count($a) <=> count($b));
|
|
|
|
foreach($recipeIngredientMatches as $ingredientIndex => $acceptedItems){
|
|
$needed = $expectedIterations;
|
|
|
|
foreach($packedProvidedItems as $itemIndex => $item){
|
|
if(!isset($acceptedItems[$itemIndex])){
|
|
continue;
|
|
}
|
|
|
|
$taken = min($needed, $item->getCount());
|
|
$needed -= $taken;
|
|
$item->setCount($item->getCount() - $taken);
|
|
|
|
if($item->getCount() === 0){
|
|
unset($packedProvidedItems[$itemIndex]);
|
|
}
|
|
|
|
if($needed === 0){
|
|
//validation passed!
|
|
continue 2;
|
|
}
|
|
}
|
|
|
|
$recipeIngredient = $recipeIngredients[$ingredientIndex];
|
|
$actualIterations = $expectedIterations - $needed;
|
|
throw new TransactionValidationException("Not enough items to satisfy recipe ingredient $recipeIngredient for $expectedIterations (only have enough items for $actualIterations iterations)");
|
|
}
|
|
|
|
if(count($packedProvidedItems) > 0){
|
|
throw new TransactionValidationException("Not all provided items were used");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param Item[] $txItems
|
|
* @param Item[] $recipeItems
|
|
*
|
|
* @phpstan-param list<Item> $txItems
|
|
* @phpstan-param list<Item> $recipeItems
|
|
*
|
|
* @throws TransactionValidationException
|
|
*/
|
|
protected function matchOutputs(array $txItems, array $recipeItems) : int{
|
|
if(count($recipeItems) === 0){
|
|
throw new TransactionValidationException("No recipe items given");
|
|
}
|
|
if(count($txItems) === 0){
|
|
throw new TransactionValidationException("No transaction items given");
|
|
}
|
|
|
|
$iterations = 0;
|
|
while(count($recipeItems) > 0){
|
|
/** @var Item $recipeItem */
|
|
$recipeItem = array_pop($recipeItems);
|
|
$needCount = $recipeItem->getCount();
|
|
foreach($recipeItems as $i => $otherRecipeItem){
|
|
if($otherRecipeItem->canStackWith($recipeItem)){ //make sure they have the same wildcards set
|
|
$needCount += $otherRecipeItem->getCount();
|
|
unset($recipeItems[$i]);
|
|
}
|
|
}
|
|
|
|
$haveCount = 0;
|
|
foreach($txItems as $j => $txItem){
|
|
if($txItem->canStackWith($recipeItem)){
|
|
$haveCount += $txItem->getCount();
|
|
unset($txItems[$j]);
|
|
}
|
|
}
|
|
|
|
if($haveCount % $needCount !== 0){
|
|
//wrong count for this output, should divide exactly
|
|
throw new TransactionValidationException("Expected an exact multiple of required $recipeItem (given: $haveCount, needed: $needCount)");
|
|
}
|
|
|
|
$multiplier = intdiv($haveCount, $needCount);
|
|
if($multiplier < 1){
|
|
throw new TransactionValidationException("Expected more than zero items matching $recipeItem (given: $haveCount, needed: $needCount)");
|
|
}
|
|
if($iterations === 0){
|
|
$iterations = $multiplier;
|
|
}elseif($multiplier !== $iterations){
|
|
//wrong count for this output, should match previous outputs
|
|
throw new TransactionValidationException("Expected $recipeItem x$iterations, but found x$multiplier");
|
|
}
|
|
}
|
|
|
|
if(count($txItems) > 0){
|
|
//all items should be destroyed in this process
|
|
throw new TransactionValidationException("Expected 0 items left over, have " . count($txItems));
|
|
}
|
|
|
|
return $iterations;
|
|
}
|
|
|
|
private function validateRecipe(CraftingRecipe $recipe, ?int $expectedRepetitions) : int{
|
|
//compute number of times recipe was crafted
|
|
$repetitions = $this->matchOutputs($this->outputs, $recipe->getResultsFor($this->source->getCraftingGrid()));
|
|
if($expectedRepetitions !== null && $repetitions !== $expectedRepetitions){
|
|
throw new TransactionValidationException("Expected $expectedRepetitions repetitions, got $repetitions");
|
|
}
|
|
//assert that $repetitions x recipe ingredients should be consumed
|
|
self::matchIngredients($this->inputs, $recipe->getIngredientList(), $repetitions);
|
|
|
|
return $repetitions;
|
|
}
|
|
|
|
public function validate() : void{
|
|
$this->squashDuplicateSlotChanges();
|
|
if(count($this->actions) < 1){
|
|
throw new TransactionValidationException("Transaction must have at least one action to be executable");
|
|
}
|
|
|
|
$this->matchItems($this->outputs, $this->inputs);
|
|
|
|
if($this->recipe === null){
|
|
$failed = 0;
|
|
foreach($this->craftingManager->matchRecipeByOutputs($this->outputs) as $recipe){
|
|
try{
|
|
//compute number of times recipe was crafted
|
|
$this->repetitions = $this->matchOutputs($this->outputs, $recipe->getResultsFor($this->source->getCraftingGrid()));
|
|
//assert that $repetitions x recipe ingredients should be consumed
|
|
self::matchIngredients($this->inputs, $recipe->getIngredientList(), $this->repetitions);
|
|
|
|
//Success!
|
|
$this->recipe = $recipe;
|
|
break;
|
|
}catch(TransactionValidationException $e){
|
|
//failed
|
|
++$failed;
|
|
}
|
|
}
|
|
|
|
if($this->recipe === null){
|
|
throw new TransactionValidationException("Unable to match a recipe to transaction (tried to match against $failed recipes)");
|
|
}
|
|
}else{
|
|
$this->repetitions = $this->validateRecipe($this->recipe, $this->repetitions);
|
|
}
|
|
}
|
|
|
|
protected function callExecuteEvent() : bool{
|
|
$ev = new CraftItemEvent($this, $this->recipe, $this->repetitions, $this->inputs, $this->outputs);
|
|
$ev->call();
|
|
return !$ev->isCancelled();
|
|
}
|
|
}
|