rtdd/behavior_pack_v8jz0zSR/Script_NeteaseModousIY5aSF/Function.py

# coding=utf-8
import time

import ModUtil as util
from BlueFoxTools.ItemTools import CreateItemDict
from BlueFoxTools.SpecialFunciton.BlockBlock import BlockBlock
from BlueFoxTools.SystemTools import SystemTools
from BlueFoxTools.ToolsConfig import *


class CookingStateEnum(object):
    Default = -1
    Boil = 0


class BaseBlock(BlockBlock):
    instances = {}
    dropItems = []

    def __init__(self, posDim, aux, posDims=None):
        super(BaseBlock, self).__init__(posDim, aux, posDims)
        self.__stirFryProperty = self.dataComp['stirFry']
        self.__boilProperty = self.dataComp['boil']
        BaseBlock.instances[self.centerPosDim] = self
        self.cookingState = CookingStateEnum.Default
        self.isFinish = False
        self.serverSystem = SystemTools.GetSystemByClsName('MainServer')

    @classmethod
    def Instances(cls):
        return cls.instances.values()

    def Tick(self):
        pass

    def BlockUse(self, playerId, itemDict):
        """玩家尝试使用方块"""

    @property
    def stirFryProperty(self):
        # type:()->int
        """
        翻炒属性，用于记录翻炒了多久
        """
        return self.__stirFryProperty if self.__stirFryProperty is not None else 0

    @stirFryProperty.setter
    def stirFryProperty(self, value):
        self.__stirFryProperty = value

    @property
    def boilProperty(self):
        # type:()->float
        """
        煮了多久
        :return:
        """
        return self.__boilProperty if self.__boilProperty is not None else 0.0

    @boilProperty.setter
    def boilProperty(self, value):
        self.__boilProperty = value

    def SaveData(self):
        self.dataComp['stirFry'] = self.__stirFryProperty
        self.dataComp['boil'] = self.__boilProperty

    def Destroy(self, drop=0):
        del BaseBlock.instances[self.centerPosDim]
        super(BaseBlock, self).Destroy(0)
        if drop:
            for dropItem in self.dropItems:
                self.serverSystem.CreateEngineItemEntity(dropItem, self.centerPosDim[3], self.centerPosDim[:3])

    def Translater(self, newBlock):
        """转换方块为新的方块"""
        cls = blockIndex.get(newBlock)
        if cls:
            self.Destroy()
            cls.getInstance(self.centerPosDim)


class WoK(BaseBlock):
    blockList = {(0, 0, 0): {'name': 'rtdd:wok', 'aux': 0}}

    def __init__(self, *args):
        super(WoK, self).__init__(*args)

    def BlockUse(self, playerId, itemDict):
        if util.Normal.GetItemOil(itemDict) and util.Normal.IsBlockBelow(
                self.centerPosDim, 'minecraft:campfire'
        ):
            self.Translater('rtdd:cookinggarlic')  # 转化为带油的煎锅
            util.Normal.SetItemOil(itemDict, False)
            serverCompFactory.CreateItem(LevelId).SpawnItemToPlayerCarried(itemDict, playerId)
            util.ServerUtil.PlaySoundToAllClient(
                self.centerPosDim, 'random.fizz', 2.4
            )


OID_CAN_MAX_SIZE = 16  # 油瓶最大油量


class OilCan(BaseBlock):
    blockList = {(0, 0, 0): {'name': 'rtdd:oilcan', 'aux': 0}}

    def __init__(self, *args):
        super(OilCan, self).__init__(*args)
        self.__oil = self.dataComp['oil']
        self.SetFill()

    def SetFill(self):
        self.oil = OID_CAN_MAX_SIZE

    def BlockUse(self, playerId, itemDict):
        if util.Normal.GetItemOil(itemDict):
            if self.oil < OID_CAN_MAX_SIZE:
                self.oil += 1
                util.Normal.SetItemOil(itemDict, False)
                serverCompFactory.CreateItem(playerId).SpawnItemToPlayerCarried(itemDict, playerId)
        elif self.oil > 0:
            util.Normal.SetItemOil(itemDict, True)
            serverCompFactory.CreateItem(playerId).SpawnItemToPlayerCarried(itemDict, playerId)
            self.oil -= 1

        serverCompFactory.CreateGame(LevelId).SetOneTipMessage(
            playerId, '剩余油量{}/{}'.format(self.oil, OID_CAN_MAX_SIZE)
        )

    @property
    def oil(self):
        return 0 if self.__oil is None else self.__oil

    @oil.setter
    def oil(self, value):
        self.__oil = value

    def SaveData(self):
        super(OilCan, self).SaveData()
        self.dataComp['oil'] = self.__oil


class CookingWok(BaseBlock):
    blockList = {(0, 0, 0): {'name': 'rtdd:cookinggarlic', 'aux': 0}}
    dropItems = [CreateItemDict('rtdd:wok')]

    def __init__(self, *args):
        super(CookingWok, self).__init__(*args)

    def BlockUse(self, playerId, itemDict):
        if itemDict and itemDict.get('newItemName') == 'minecraft:beef':
            self.Translater('rtdd:carrotandbeef')
            util.ServerUtil.PlaySoundToAllClient(
                self.centerPosDim, 'random.fizz', 0.8
            )


class CarrotAndBeef(BaseBlock):
    blockList = {(0, 0, 0): {'name': 'rtdd:carrotandbeef', 'aux': 0}}
    dropItems = [CreateItemDict('rtdd:wok'), CreateItemDict('minecraft:beef')]

    def __init__(self, *args):
        super(CarrotAndBeef, self).__init__(*args)
        self.stirTime = time.time()

    def BlockUse(self, playerId, itemDict):
        stirTime = time.time()
        if stirTime - self.stirTime > 1.2:
            if itemDict and itemDict.get('newItemName') == 'minecraft:wooden_sword':
                self.stirFryProperty += 1
                util.ServerUtil.PlaySoundToAllClient(
                    self.centerPosDim, 'random.fizz', 2.1
                )
                util.ServerUtil.PlayAttackToClient(playerId)
                self.ReplaceBlocks({(0, 0, 0): {'name': 'rtdd:carrotandbeef', 'aux': self.stirFryProperty % 4}})
                if self.stirFryProperty > 5:
                    self.Translater('rtdd:carrotandbeef_1')
                self.stirTime = stirTime
        else:
            serverCompFactory.CreateGame(LevelId).SetOneTipMessage(playerId, '这时候翻动会不好熟的!')


class CarrotAndBeef1(BaseBlock):
    blockList = {(0, 0, 0): {'name': 'rtdd:carrotandbeef_1', 'aux': 0}}
    dropItems = [CreateItemDict('rtdd:wok'), CreateItemDict('minecraft:beef')]

    def __init__(self, *args):
        super(CarrotAndBeef1, self).__init__(*args)
        self.stirTime = time.time()

    def BlockUse(self, playerId, itemDict):
        stirTime = time.time()
        if stirTime - self.stirTime > 0.8:
            if itemDict and itemDict.get('newItemName') == 'minecraft:wooden_sword' and not self.isFinish:
                self.stirFryProperty += 1
                util.ServerUtil.PlaySoundToAllClient(
                    self.centerPosDim, 'random.fizz', 2.1
                )
                util.ServerUtil.PlayAttackToClient(playerId)
                self.ReplaceBlocks({(0, 0, 0): {'name': 'rtdd:carrotandbeef_1', 'aux': self.stirFryProperty % 4}})
                self.isFinish = self.stirFryProperty > 3
            elif itemDict and itemDict.get('newItemName') == 'minecraft:wooden_sword' and self.isFinish:
                serverCompFactory.CreateGame(LevelId).SetOneTipMessage(playerId, '出锅啦!拿盘子盛出来')
        else:
            serverCompFactory.CreateGame(LevelId).SetOneTipMessage(playerId, '这时候翻动会不好熟的!')

    def Destroy(self, drop=0):
        if self.isFinish: self.dropItems = [CreateItemDict('minecraft:cooked_beef'), CreateItemDict('rtdd:wok')]
        super(CarrotAndBeef1, self).Destroy(drop)


blockIndex = {
    'rtdd:wok': WoK,
    'rtdd:cookinggarlic': CookingWok,
    'rtdd:carrotandbeef': CarrotAndBeef,
    'rtdd:carrotandbeef_1': CarrotAndBeef1,
    'rtdd:oilcan': OilCan
}


def GetBaseBlock(posDim):
    # type:(Tuple)->BaseBlock
    return BaseBlock.instances.get(posDim)