BurnedOut
Beloved Antichrist
Posting the pseudocode. It is in python.
I have a writer's block. Will keep updating this later.
This section holds the global variables. The intrinsic mechanisms that change but never disappear. All the interactions happens around these variables and with these variables.
This section contains the mechanisms through which the variables are used. These are defined in an OOP style format to be more lucid. I will post explanations later.
These codes don't work. They are just paradigms. Come here after you are done reading
1) https://www.intpforum.com/threads/extension-we-are-related-to-each-other-by-6-people.28483/
2) https://www.intpforum.com/threads/self-worth-breakdown-and-application.28485/
For those who did not understand the code, don't worry. I am going to post a long explanation that will be devoid of any kind of programming and mathematic jargon.
I have a writer's block. Will keep updating this later.
This section holds the global variables. The intrinsic mechanisms that change but never disappear. All the interactions happens around these variables and with these variables.
Python:
from classes import *
"""
g_profession = current profession of the subject
g_personality = current personality of the subject. personality = read only list of traits
g_skills = skillset of the subject = list
g_intrinsicWorth = original iw of the subject
g_potentialWorth = original pw of the subject obtained by the summation of .potential of each skill.
"""
g_subject = Subject(name='Hritik')
g_profession = g_subject.profession # current profession
g_personality = g_subject.personality # Tuple of personality traits
g_skills = g_subject.skills # List of skills
g_intrinsicWorth = g_subject.intrinsicWorth # You get it.
g_potentialWorth = g_subject.potentialWorth # You get it.
g_satisfaction = g_subject.satisfaction
"""
g_skillsetPersonalityMap:
[key][sublevel1][skillset]
represents the type of skill owned by the subject (boxing, painting, pissing at the top of the house from below, etc)
[key][sublevel2][personality]
represents the personality of the individual by a list of traits (tuple[str])
g_skillsetPersonalityMap = {
"skillset1" : {
"personality1" : STR READONLY LIST,
"personality2" : STR READONLY LIST,
},
"skillset2" : {
"personality1" : STR READONLY LIST,
"personality2" : STR READONLY LIST,
},
}
------------------------------------
g_personalitySWMultiplierMap:
[key][personality] STR READONLY LIST (tuple):
Represents the multiplier obtained by the personality of an individual to get SW. This multiplier helps in getting a more accurate value of SW.
g_personalitySWMultiplierMap = {
personality1 : INT,
personality2 : INT,
}
a------------------------------------
g_remainingGrasping: FLOAT
Represents the cognitive capacity to new skills
------------------------------------
g_skills : Hash[Skill]
[skillname]: Alias of the skill
g_skills = {
"skillname1" : Skill1,
"skillname2" : Skill2,
...
}
------------------------------------
g_selfWorth : Object[SelfWorth]
------------------------------------
g_filter: List
The amount of skills that can be learned but not adequately used. When len(g_filter) == g_filterLimit, the there will be a
"""
g_personalitySWMultiplierMap = {}
g_skillsetPersonalityMap = {}
g_remainingGrasping = 1.0
multiplier = g_personalitySWMultiplierMap[g_personality]
g_selfWorth = SelfWorth(g_intrinsicWorth, g_potentialWorth, multiplier)
g_filter = []
g_filterLimit = 5This section contains the mechanisms through which the variables are used. These are defined in an OOP style format to be more lucid. I will post explanations later.
Python:
from dataclasses import dataclass, field
import typing
from globalvars import *
@dataclass
class SelfWorth:
"""
Self worth needs to be updated after adding a new skill.
"""
selfWorth: float = 0.0
intrinsic: float
potential: float
# Accuracy multiplier obtained by Markov Analyasis of Individual's Actions
multiplier: float
def Get():
return self.intrinsic * self.potential * self.multiplier # Simple SW Index
def Update():
self.selfWorth = self.Get()
@dataclass
class Subject:
# Only this should be put as a parameter
name: str
intrinsicWorth: int = 0.0
potentialWorth: int = 0.0
# An object
selfWorth: SelfWorth
skills: list
# elements cannot be changed
personality: tuple
satisfaction: 0.0
filterCapacity: 4
@dataclass
class Skill:
# The sister subjects are merely a specification and not a given
# List of Sister Skills that will affect bg, ag, ug
sisters: list[Skill]
# Alias
name: Str
# Buffer Grasping - Spontaneous grasping
bg: Int
# Augmented Grasping - bg is the base for this grasping which is 'augmented'. If the person has poor bg then this will be high. he will have to work more to augment his grasping.
ag: Int
# Unique Grasping - What is remaining. The independent 'essence' of the subject. however it is correlated with what the individual already knows
ug: Int
# Predetermined constant which indicates how valuable learning this skill is. It is measured in terms of money (for ease of measuring)
potential: Int
def AddSkill(skill: Skill):
"""
Add a sister skill through this skill.
If this is done then the buffer grasping required for that subject will be increased.
Furthermore, this will augment the grasping capacity of the individual.
The bg of this skill will not increase because it has been already been learned.
To avoid double counting, it checks if the skill being added is not already present in the skillset of the individual.
If the skill being added through this skill is unrelated then it will hurt the remaining cognitive capacity of the individual.
It increases the PW too if a sister skill is added.
"""
# Cannot use the cognition any further to learn a new skill. Return
if g_filterLimit == len(g_filter):
return
if skill in self.sisters:
skill.bg += self.bg
# This will be reduced, obviously
skill.ag -= self.ag
skill.ug = 1 - (self.bg + self.ag)
g_skills.append(skill)
# update the multiplier
newPersonality = g_skillsetPersonalityMap[g_skills]
newMultiplier = g_personalitySWMultiplierMap[g_personality]
currentIW = g_selfWorth.intrinsic
potentialIW = g_selfWorth.potential
g_selfWorth = SelfWorth(currentIW, potentialIW, newMultiplier)
# To avoid double counting
if not g_skills[skill.name]:
g_remainingGrasping += skill.bg
else:
"""
Learning a completely random skill does not affect its bg, ag and ug. However, it consumes moreof your brain capacity unnecessarily.
After a threshold of remainingGrasping is crossed, Intrinsic Worth of the individual starts getting affected. In other words, Intrinsic Worth is now correlated with Potential Worth.
"""
if not g_skills[skill.name]:
g_remainingGrasping -= skill.bg
g_skills.append(skill)
if len(g_filter) < g_filterLimit:
g_filter.append(skill)
else:
g_satisfaction -= FILTERCONST * skill.potential
# update the multiplier
newPersonality = g_skillsetPersonalityMap[g_skills]
newMultiplier = g_personalitySWMultiplierMap[g_personality]
currentIW = g_selfWorth.intrinsic
potentialIW = g_selfWorth.potential
g_selfWorth = SelfWorth(currentIW, potentialIW, newMultiplier)These codes don't work. They are just paradigms. Come here after you are done reading
1) https://www.intpforum.com/threads/extension-we-are-related-to-each-other-by-6-people.28483/
2) https://www.intpforum.com/threads/self-worth-breakdown-and-application.28485/
For those who did not understand the code, don't worry. I am going to post a long explanation that will be devoid of any kind of programming and mathematic jargon.