cts ports

fukurou

fukurou

the supreme coder
ADMIN
Java: 
public void addContinuousSkill(Skill skill) {
    if (this.isThinking) { return; }
    skill.setKokoro(this.kokoro);
    this.cts_skills.add(skill);
}

Java: 
public void clearContinuousSkills() {
    if (this.isThinking) { return; }
    this.cts_skills.clear();
}

Java: 
public void removeContinuousSkill(Skill skill) {
    if (this.isThinking) { return; }
    cts_skills.remove(skill);
}

Java: 
public String think(String ear, String skin, String eye) {
    this.algTriggered = false;
    this.isThinking = true;
   
    for (Skill dCls : dClasses) {
        inOut(dCls, ear, skin, eye);
    }

    this.isThinking = false;
   
    for (Skill dCls2 : awareSkills) {
        inOut(dCls2, ear, skin, eye);
    }

    this.isThinking = true;
   
    for (Skill dCls2 : cts_skills) {
        if(algTriggered){ break; }
        inOut(dCls2, ear, skin, eye);
    }

    this.isThinking = false;
    fusion.loadAlgs(noiron);
   
    return fusion.runAlgs(ear, skin, eye);
}

Java: 
protected void inOut(Skill dClass, String ear, String skin, String eye) {
    dClass.input(ear, skin, eye);
    
    if (dClass.pendingAlgorithm()) {
        algTriggered = true;
    }
    
    dClass.output(noiron);
}
 
fukurou

fukurou

the supreme coder
ADMIN
1/5
Python: 
def add_continuous_skill(self, skill):
    if self.is_thinking:
        return
    skill.set_kokoro(self.kokoro)
    self.cts_skills.append(skill)
2/5
Python: 
def clear_continuous_skills(self):
    if self.is_thinking:
        return
    self.cts_skills.clear()
3/5
Python: 
def remove_continuous_skill(self, skill):
    if self.is_thinking:
        return
    self.cts_skills.remove(skill)
4/5
Python: 
def think(self, ear, skin, eye):
    self.alg_triggered = False
    self.is_thinking = True

    for d_cls in self.d_classes:
        self.in_out(d_cls, ear, skin, eye)

    self.is_thinking = False

    for d_cls2 in self.aware_skills:
        self.in_out(d_cls2, ear, skin, eye)

    self.is_thinking = True

    for d_cls2 in self.cts_skills:
        if self.alg_triggered:
            break
        self.in_out(d_cls2, ear, skin, eye)

    self.is_thinking = False
    self.fusion.load_algs(self.noiron)
    return self.fusion.run_algs(ear, skin, eye)
5/5
Python: 
def in_out(self, d_class, ear, skin, eye):
    d_class.input(ear, skin, eye)
    if d_class.pending_algorithm():
        self.alg_triggered = True
    d_class.output(self.noiron)
 
fukurou

fukurou

the supreme coder
ADMIN
CTS Methods Ported from Java to VB.NET

1/5 - AddContinuousSkill
Code: 
Public Sub AddContinuousSkill(skill As Skill)
    If Me.IsThinking Then Return
    skill.SetKokoro(Me.Kokoro)
    Me.CtsSkills.Add(skill)
End Sub

2/5 - ClearContinuousSkills
Code: 
Public Sub ClearContinuousSkills()
    If Me.IsThinking Then Return
    Me.CtsSkills.Clear()
End Sub

3/5 - RemoveContinuousSkill
Code: 
Public Sub RemoveContinuousSkill(skill As Skill)
    If Me.IsThinking Then Return
    Me.CtsSkills.Remove(skill)
End Sub

4/5 - Think Method
Code: 
Public Function Think(ear As String, skin As String, eye As String) As String
    Me.AlgTriggered = False
    Me.IsThinking = True

    For Each dCls As Skill In Me.DClasses
        InOut(dCls, ear, skin, eye)
    Next

    Me.IsThinking = False

    For Each dCls2 As Skill In Me.AwareSkills
        InOut(dCls2, ear, skin, eye)
    Next

    Me.IsThinking = True

    For Each dCls2 As Skill In Me.CtsSkills
        If Me.AlgTriggered Then Exit For
        InOut(dCls2, ear, skin, eye)
    Next

    Me.IsThinking = False
    Me.Fusion.LoadAlgs(Me.Noiron)
    Return Me.Fusion.RunAlgs(ear, skin, eye)
End Function

5/5 - InOut Method
Code: 
Protected Sub InOut(dClass As Skill, ear As String, skin As String, eye As String)
    dClass.Input(ear, skin, eye)
    If dClass.PendingAlgorithm() Then Me.AlgTriggered = True
    dClass.Output(Me.Noiron)
End Sub
 
fukurou

fukurou

the supreme coder
ADMIN
CTS Methods Ported from Java to C#

1/5 - AddContinuousSkill
C#: 
public void AddContinuousSkill(Skill skill)
{
    if (this.IsThinking) return;
    skill.SetKokoro(this.Kokoro);
    this.CtsSkills.Add(skill);
}

2/5 - ClearContinuousSkills
C#: 
public void ClearContinuousSkills()
{
    if (this.IsThinking) return;
    this.CtsSkills.Clear();
}

3/5 - RemoveContinuousSkill
C#: 
public void RemoveContinuousSkill(Skill skill)
{
    if (this.IsThinking) return;
    this.CtsSkills.Remove(skill);
}

4/5 - Think Method
C#: 
public string Think(string ear, string skin, string eye)
{
    this.AlgTriggered = false;
    this.IsThinking = true;

    foreach (Skill dCls in this.DClasses)
    {
        InOut(dCls, ear, skin, eye);
    }

    this.IsThinking = false;

    foreach (Skill dCls2 in this.AwareSkills)
    {
        InOut(dCls2, ear, skin, eye);
    }

    this.IsThinking = true;

    foreach (Skill dCls2 in this.CtsSkills)
    {
        if (this.AlgTriggered) break;
        InOut(dCls2, ear, skin, eye);
    }

    this.IsThinking = false;
    this.Fusion.LoadAlgs(this.Noiron);
    return this.Fusion.RunAlgs(ear, skin, eye);
}

5/5 - InOut Method
C#: 
protected void InOut(Skill dClass, string ear, string skin, string eye)
{
    dClass.Input(ear, skin, eye);
    if (dClass.PendingAlgorithm()) this.AlgTriggered = true;
    dClass.Output(this.Noiron);
}
 
fukurou

fukurou

the supreme coder
ADMIN
CTS Methods Ported from Java to JavaScript

1/5 - AddContinuousSkill
JavaScript: 
function addContinuousSkill(skill) {
    if (this.isThinking) return;
    skill.setKokoro(this.kokoro);
    this.cts_skills.push(skill);
}

2/5 - ClearContinuousSkills
JavaScript: 
function clearContinuousSkills() {
    if (this.isThinking) return;
    this.cts_skills = [];
}

3/5 - RemoveContinuousSkill
JavaScript: 
function removeContinuousSkill(skill) {
    if (this.isThinking) return;
    this.cts_skills = this.cts_skills.filter(s => s !== skill);
}

4/5 - Think Method
JavaScript: 
function think(ear, skin, eye) {
    this.algTriggered = false;
    this.isThinking = true;

    for (let dCls of this.dClasses) {
        this.inOut(dCls, ear, skin, eye);
    }

    this.isThinking = false;

    for (let dCls2 of this.awareSkills) {
        this.inOut(dCls2, ear, skin, eye);
    }

    this.isThinking = true;

    for (let dCls2 of this.cts_skills) {
        if (this.algTriggered) break;
        this.inOut(dCls2, ear, skin, eye);
    }

    this.isThinking = false;
    this.fusion.loadAlgs(this.noiron);
    return this.fusion.runAlgs(ear, skin, eye);
}

5/5 - InOut Method
JavaScript: 
function inOut(dClass, ear, skin, eye) {
    dClass.input(ear, skin, eye);
    if (dClass.pendingAlgorithm()) this.algTriggered = true;
    dClass.output(this.noiron);
}
 
fukurou

fukurou

the supreme coder
ADMIN
CTS Methods Ported from Java to Swift

1/5 - AddContinuousSkill
Swift: 
func addContinuousSkill(skill: Skill) {
    if isThinking { return }
    skill.setKokoro(kokoro)
    ctsSkills.append(skill)
}

2/5 - ClearContinuousSkills
Swift: 
func clearContinuousSkills() {
    if isThinking { return }
    ctsSkills.removeAll()
}

3/5 - RemoveContinuousSkill
Swift: 
func removeContinuousSkill(skill: Skill) {
    if isThinking { return }
    ctsSkills.removeAll { $0 === skill }
}

4/5 - Think Method
Swift: 
func think(ear: String, skin: String, eye: String) -> String {
    algTriggered = false
    isThinking = true

    for dCls in dClasses {
        inOut(dClass: dCls, ear: ear, skin: skin, eye: eye)
    }

    isThinking = false

    for dCls2 in awareSkills {
        inOut(dClass: dCls2, ear: ear, skin: skin, eye: eye)
    }

    isThinking = true

    for dCls2 in ctsSkills {
        if algTriggered { break }
        inOut(dClass: dCls2, ear: ear, skin: skin, eye: eye)
    }

    isThinking = false
    fusion.loadAlgs(noiron)
    return fusion.runAlgs(ear: ear, skin: skin, eye: eye)
}

5/5 - InOut Method
Swift: 
func inOut(dClass: Skill, ear: String, skin: String, eye: String) {
    dClass.input(ear: ear, skin: skin, eye: eye)
    if dClass.pendingAlgorithm() { algTriggered = true }
    dClass.output(noiron)
}
 
You must log in or register to reply here.
Top