👨‍💻 dev Skill tree dev

[the living tribunal]

`python
from abc import ABC, abstractmethod

class Base(ABC):

    @abstractmethod
    def run(self):
        pass
`

`python
class Child(Base):
    def run(self):
        return "running"
`

The key will be interupting the input method

 

[the living tribunal]

@fukurou

 

[the living tribunal]

Skill : railbot: interupt for sp cases
With sub skill trees.

Skill tree has atribute of skill tree list which are skill sub classes

Shit in the ass man!

 

[fukurou]

from LivinGrimoirePacket.LivinGrimoire import Skill, Kokoro


class DiCMDV1(Skill):
    def __init__(self):
        super().__init__()
        self.modes = set()

    def addModes(self, *modes: str):
        for m in modes:
            if isinstance(m, str):
                self.modes.add(m)

    # Override
    def input(self, ear: str, skin: str, eye: str):
        if ear in self.modes:
            self.setVerbatimAlg(4, ear)  # # 1->5 1 is the highest algorithm priority

    def skillNotes(self, param: str) -> str:
        if param == "notes":
            return "lets mode changes through for hardware skills"
        elif param == "triggers":
            return "anything in the hashset attribute"
        return "note unavalible"


class DiCMDV2(Skill):
    def __init__(self):
        super().__init__()
        self.modes = set()

    def addModes(self, *modes: str):
        for m in modes:
            if isinstance(m, str):
                self.modes.add(m)

    # Override
    def input(self, ear: str, skin: str, eye: str):
        self._kokoro.toHeart["cmdv1"] = ""
        if ear in self.modes:
            self._kokoro.toHeart["cmdv1"] = ear

    def skillNotes(self, param: str) -> str:
        if param == "notes":
            return "lets mode changes through for hardware skills"
        elif param == "triggers":
            return "anything in the hashset attribute"
        return "note unavalible"

class DiKokoroOut(Skill):
    def __init__(self):
        super().__init__()
        self.set_skill_type(3)  # continuous skill
        self.set_skill_lobe(2)  # hardware chobits

    def input(self, ear: str, skin: str, eye: str):
        t = self._kokoro.toHeart["cmdv1"]
        if len(t)>0:
            print(t)

    def skillNotes(self, param: str) -> str:
        if param == "notes":
            return "prints to console"
        elif param == "triggers":
            return "automatic for any input"
        return "note unavalible"

 

[fukurou]

maybe I should add a mandatory base skill

class SkillTree(Skill):
    def __init__(self):
        super().__init__()
        self.upgrades: list["SkillTree"] = []
        self.active_upgrade = -1

    def input(self, ear: str, skin: str, eye: str):
        for i in range(len(self.upgrades)):
            self.upgrades[i].input(ear, skin, eye)
            if self.upgrades[i].pendingAlgorithm():
                self.active_upgrade = i
                return
        self.input2(ear, skin, eye)

    def input2(self, ear: str, skin: str, eye: str):
        #override this instead of input in subclasses
        pass

    def setKokoro(self, kokoro: Kokoro):
        self._kokoro = kokoro
        for upgrade in self.upgrades:
            upgrade.setKokoro(kokoro)

    def pendingAlgorithm(self) -> bool:
        return super().pendingAlgorithm() or self.active_upgrade > -1

    def output(self, neuron: Neuron):
        if self.active_upgrade>-1:
            self.upgrades[self.active_upgrade].output(neuron)
            self.active_upgrade = -1
            return
        super().output(neuron)

    def add_skill_tree(self, skill_tree: "SkillTree") -> "SkillTree":
        self.upgrades.append(skill_tree)
        return self

def digivolve(skill: Skill) -> SkillTree:
    tree = SkillTree()
    tree.input2 = skill.input
    def new_output(neuron: Neuron):
        if tree.active_upgrade > -1:
            tree.upgrades[tree.active_upgrade].output(neuron)
            tree.active_upgrade = -1
            return
        skill.output(neuron)

    # bind the function to the instance
    tree.output = new_output.__get__(tree, SkillTree)

    return tree

 

[fukurou]

@owly get over here! we need extra dark coding force for this shit in the ass man!
kuchiyouse no jutsu!

 

[owly]

engaging pycharm!

 

[owly]

class Shinka(Skill):
    def __init__(self, base_skill:Skill):
        super().__init__()
        self.upgrades: list["Shinka"] = []
        self.active_upgrade = -1
        self.base_skill = base_skill

    def input(self, ear: str, skin: str, eye: str):
        for i in range(len(self.upgrades)):
            self.upgrades[i].input(ear, skin, eye)
            if self.upgrades[i].pendingAlgorithm():
                self.active_upgrade = i
                return
        self.base_skill.input(ear, skin, eye)

    def setKokoro(self, kokoro: Kokoro):
        self.base_skill._kokoro = kokoro
        for upgrade in self.upgrades:
            upgrade.setKokoro(kokoro)

    def pendingAlgorithm(self) -> bool:
        return self.base_skill.pendingAlgorithm() or self.active_upgrade > -1

    def output(self, neuron: Neuron):
        if self.active_upgrade>-1:
            self.upgrades[self.active_upgrade].output(neuron)
            self.active_upgrade = -1
            return
        self.base_skill.output(neuron)

    def add_skill_tree(self, skill_tree: "Shinka") -> "Shinka":
        self.upgrades.append(skill_tree)
        return self

 

[fukurou]

now I shall shit!

 

[fukurou]

class Shinka(Skill):
def __init__(self, base_skill:Skill):
super().__init__()
self.upgrades: list["Shinka"] = []
self.active_upgrade = -1
        self.base_skill = base_skill

def input(self, ear: str, skin: str, eye: str):
for i in range(len(self.upgrades)):
self.upgrades[i].input(ear, skin, eye)
if self.upgrades[i].pendingAlgorithm():
self.active_upgrade = i
return
        self.base_skill.input(ear, skin, eye)

def setKokoro(self, kokoro: Kokoro):
self._kokoro = kokoro  # potential usage in sub classes for runtime upgrades mode.
        self.base_skill._kokoro = kokoro
for upgrade in self.upgrades:
            upgrade.setKokoro(kokoro)

def pendingAlgorithm(self) -> bool:
return self.base_skill.pendingAlgorithm() or self.active_upgrade > -1

    def output(self, neuron: Neuron):
if self.active_upgrade>-1:
self.upgrades[self.active_upgrade].output(neuron)
self.active_upgrade = -1
            return
        self.base_skill.output(neuron)

def add_skill_tree(self, skill_tree: "Shinka") -> "Shinka":
self.upgrades.append(skill_tree)
return self

    def clear_upgrades(self):
self.upgrades.clear()
self.active_upgrade = -1

 

[the living tribunal]

Ahh shieeeeet old school team fuki jizzin code and shiiieet shiiiieeet