SimpleInventory.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;
 
use pocketmine\item\Item;
use pocketmine\item\VanillaItems;
use pocketmine\player\InventoryWindow;
use pocketmine\player\Player;
use function array_map;
use function spl_object_id;
 
class SimpleInventory extends BaseInventory{
    protected \SplFixedArray $slots;
 
    protected array $windows = [];
 
    public function __construct(int $size){
        $this->slots = new \SplFixedArray($size);
        parent::__construct();
    }
 
    public function getSize() : int{
        return $this->slots->getSize();
    }
 
    public function getItem(int $index) : Item{
        return $this->slots[$index] !== null ? clone $this->slots[$index] : VanillaItems::AIR();
    }
 
    protected function internalSetItem(int $index, Item $item) : void{
        $this->slots[$index] = $item->isNull() ? null : $item;
    }
 
    public function getContents(bool $includeEmpty = false) : array{
        $contents = [];
 
        foreach($this->slots as $i => $slot){
            if($slot !== null){
                $contents[$i] = clone $slot;
            }elseif($includeEmpty){
                $contents[$i] = VanillaItems::AIR();
            }
        }
 
        return $contents;
    }
 
    protected function internalSetContents(array $items) : void{
        for($i = 0, $size = $this->getSize(); $i < $size; ++$i){
            if(!isset($items[$i]) || $items[$i]->isNull()){
                $this->slots[$i] = null;
            }else{
                $this->slots[$i] = clone $items[$i];
            }
        }
    }
 
    public function getMatchingItemCount(int $slot, Item $test, bool $checkTags) : int{
        $slotItem = $this->slots[$slot];
        return $slotItem !== null && $slotItem->equals($test, true, $checkTags) ? $slotItem->getCount() : 0;
    }
 
    public function isSlotEmpty(int $index) : bool{
        return $this->slots[$index] === null || $this->slots[$index]->isNull();
    }
 
    public function getViewers() : array{
        $result = [];
        //this can't use array_map - the result needs to be keyed by spl_object_id(player), not spl_object_id(window)
        foreach($this->windows as $window){
            $player = $window->getViewer();
            $result[spl_object_id($player)] = $player;
        }
        return $result;
    }
 
    public function removeAllWindows() : void{
        foreach($this->windows as $hash => $window){
            $viewer = $window->getViewer();
            if($window->getViewer()->getCurrentWindow() === $window){
                $viewer->removeCurrentWindow();
            }
            unset($this->windows[$hash]);
        }
    }
 
    public function onOpen(InventoryWindow $window) : void{
        $this->windows[spl_object_id($window)] = $window;
    }
 
    public function onClose(InventoryWindow $window) : void{
        unset($this->windows[spl_object_id($window)]);
    }
}