private Personality(string name, PersonalityType type, CharaStatusType upwardStausType, CharaStatusType downwardStausType)
{
Name = name;
Type = type;
UpwardStausType = upwardStausType;
DownwardStausType = downwardStausType;
}
public Bod CreateNewFreelancer(string name, PersonalityType pt = PersonalityType.NONE)
{
Bod bod = CreateNewBod(name, pt, BodClass.FREELANCER);
bod.SetFightingSkill(1);
return(bod);
}
public Bod CreateNewGuard(string name, string houseName, PersonalityType pt = PersonalityType.NONE)
{
Bod bod = CreateNewBod(name, houseName, pt, BodClass.GUARD);
bod.SetStrength(2);
bod.SetFightingSkill(2);
return(bod);
}
public void PersonalityTypesProvideASummaryOfCharacterBehaviorsBasedOnMyersBriggs()
{
var personality = new PersonalityType("INFP");
Assert.Equal(PersonalityTypes.Attitude.Introverted, personality.Attitude);
Assert.Equal(PersonalityTypes.Information.Intuitive, personality.InformationProcessing);
Assert.Equal(PersonalityTypes.DecisionMaking.Feeling, personality.DecisionMaking);
Assert.Equal(PersonalityTypes.Structure.Perceiving, personality.Structure);
}
public OneLineBanter(string content, PositionType position = PositionType.None, PersonalityType personality = PersonalityType.None, int lowPersonality = 0, int highPersonality = 100, bool onAir = true)
{
line = content;
crewPosition = position;
personalityType = personality;
minPersonality = lowPersonality;
maxPersonality = highPersonality;
radioBroadcast = onAir;
}
public Bod(string n, string hn, PersonalityType pt, BodClass bc)
{
m_name = n;
m_houseName = hn;
m_personalityType = pt;
m_bodClass = bc;
SetInjury(0);
}
public IHttpActionResult GetPersonalityType(int id)
{
PersonalityType personalitytype = DataRepository.PersonalityType.Get(id);
if (personalitytype == null)
{
return(NotFound());
}
return(Ok(personalitytype));
}
public Bod CreateNewLordBod(string name, string houseName, PersonalityType pt = PersonalityType.NONE, bool isCombatant = false)
{
Bod bod = CreateNewBod(name, houseName, pt, BodClass.LORD);
bod.SetStrength(2);
bod.SetAgility(2);
bod.SetMind(2);
if (isCombatant)
{
bod.SetFightingSkill(1);
}
return(bod);
}
public Bod CreateNewBod(string name, PersonalityType pt = PersonalityType.NONE, BodClass bc = BodClass.NONE)
{
if (pt == PersonalityType.NONE)
{
pt = GetRandomPersonalityType();
}
Bod bod = new Bod(name, "", pt, bc);
bod.SetStrength(1);
bod.SetAgility(1);
bod.SetMind(1);
return(bod);
}
public IHttpActionResult PostPersonalityType(PersonalityType personalitytype)
{
try
{
DataRepository.PersonalityType.Insert(personalitytype);
}
catch (Exception ex)
{
//string message = ExceptionHelper.GetMessageRecursively(ex);
string message = ex.GetMessageRecursively();
return(BadRequest(message));
}
return(CreatedAtRoute("DefaultApi", new { id = personalitytype.Id }, personalitytype));
}
public MammalLion()
{
diet = DietTypes.CARNIVORE;
int randHP = Random.Range(20, 24);
hitPoints = randHP;
tailLength = TailLength.LONG;
PersonalityType randPersonality = (PersonalityType)Random.Range(0, 2);
personality = randPersonality;
}
public MammalDeer()
{
diet = DietTypes.HERBIVORE;
int randHP = Random.Range(10, 12);
hitPoints = randHP;
tailLength = TailLength.SHORT;
PersonalityType randPersonality = (PersonalityType)Random.Range(0, 2);
personality = randPersonality;
}
private void SetPersonality(string personalityType)
{
// DB에 personalityType 저장
test.PersonalityTypeId = personalityTypes[personalityType];
DataRepository.Test.Update(test);
// lblType, lblCharacteristic
PersonalityType myPersonalityType = DataRepository.PersonalityType.Get((int)test.PersonalityTypeId);
//PersonalityType myPersonalityType = DataRepository.PersonalityType.Get(personalityTypes[personalityType]);
lblType.Text = myPersonalityType.Type;
lblCharacteristic.Text = myPersonalityType.Characteristic;
}
public IHttpActionResult PutPersonalityType(int id, PersonalityType personalitytype)
{
try
{
DataRepository.PersonalityType.Update(personalitytype);
}
catch (Exception ex)
{
//string message = ExceptionHelper.GetMessageRecursively(ex);
string message = ex.GetMessageRecursively();
return(BadRequest(message));
}
return(StatusCode(HttpStatusCode.NoContent));
}
private void InitPlayer()
{
var status = PhotonArenaManager.Instance.GetCurrentDepthLevel();
if ((status == PhotonArenaManager.ServerDepthLevel.InRoom) && (neighbourhoodMan != null))
{
myPlayerID = PhotonArenaManager.Instance.GetLocalPlayerID();
floatingUsernameTxt.text = PhotonArenaManager.Instance.GetLocalUsername();
myPersonality = GetMyPersonality();
SelectHat((int)myPersonality);
_playerInitialized = true;
}
}
public void CanLoadPersonalityType()
{
var data = new MemoryStore();
data.SetValue("type", "ISTJ");
data.SetValue("descriptors", new string[] { "Quiet", "Serious", "Focused" });
data.SetValue("weaknesses", new string[] { "Arrogant", "Self-Centered" });
var personality = new PersonalityType(data);
Assert.Equal(PersonalityTypes.Attitude.Introverted, personality.Attitude);
Assert.Equal(PersonalityTypes.Information.Sensing, personality.InformationProcessing);
Assert.Equal(PersonalityTypes.DecisionMaking.Thinking, personality.DecisionMaking);
Assert.Equal(PersonalityTypes.Structure.Judging, personality.Structure);
Assert.Equal("Quiet", personality.Descriptors.ElementAt(0));
Assert.Equal("Arrogant", personality.Weaknesses.ElementAt(0));
}
public AvianFalcon()
{
float randWingspan = Random.Range(2.4f, 3.9f);
wingspan = randWingspan;
int randHP = Random.Range(15, 18);
hitPoints = randHP;
TalonSize randTalons = (TalonSize)Random.Range(0, 2);
talonSize = randTalons;
PersonalityType randPersonality = (PersonalityType)Random.Range(0, 3);
personality = randPersonality;
}
public AvianParrot()
{
float randWingspan = Random.Range(3.4f, 4.1f);
wingspan = randWingspan;
int randHP = Random.Range(5, 13);
hitPoints = randHP;
TalonSize randTalons = (TalonSize)Random.Range(0, 2);
talonSize = randTalons;
PersonalityType randPersonality = (PersonalityType)Random.Range(0, 3);
personality = randPersonality;
}
public AvianHawk()
{
float randWingspan = Random.Range(3.4f, 5.8f);
wingspan = randWingspan;
int randHP = Random.Range(10, 16);
hitPoints = randHP;
TalonSize randTalons = (TalonSize)Random.Range(0, 2);
talonSize = randTalons;
PersonalityType randPersonality = (PersonalityType)Random.Range(0, 3);
personality = randPersonality;
}
/// <summary>
/// Initializes a new instance of the <see cref="TacticalMindInput"/> class.
/// </summary>
/// <param name="mainCharacterPersonality">Main character personality.</param>
/// <param name="opponentPersonality">Opponent personality.</param>
/// <param name="opponentStrategy">Opponent strategy.</param>
/// <param name="mainCharacterRanks">Main character ranks.</param>
/// <param name="opponentRanks">Opponent ranks.</param>
/// <param name="fighterConditions">Fighter conditions.</param>
public TacticalMindInput(int actionsPerTurn,
int turn,
PersonalityType mainCharacterPersonality,
PersonalityType opponentPersonality,
StrategyType opponentStrategy,
List <FightingStyleRank> mainCharacterRanks,
List <FightingStyleRank> opponentRanks,
List <ICondition> fighterConditions)
{
_actionsPerTurn = actionsPerTurn;
_turn = turn;
_mainCharacterPersonality = mainCharacterPersonality;
_opponentPersonality = opponentPersonality;
_opponentStrategy = opponentStrategy;
_mainCharacterRanks = mainCharacterRanks;
_opponentRanks = opponentRanks;
_fighterConditions = fighterConditions;
}
public string GetDescription(SexType sexType, RaceType raceType, PersonalityType personalityType, ClassType classType)
{
var builder = new StringBuilder();
builder.Append("あなたは");
builder.Append(this.raceMap[raceType]);
builder.Append("の");
builder.Append(this.sexMap[sexType]); // TODO: 後で変数化する.
builder.Append("で");
builder.Append(this.personalityMap[personalityType]);
if (personalityType != PersonalityType.Nimble)
{
builder.Append("の");
}
builder.Append(this.classMap[classType]);
builder.Append("です");
return(builder.ToString());
}
public IActionResult ChangePersonalityType([FromRoute] Guid id, PersonalityType personalityType)
{
var currentUser = User.GetUser(_databaseController);
if (currentUser.Id != id)
{
throw new InsufficientPermissionException(currentUser.Id, $"Modify({id})");
}
try
{
_databaseController.Users.ChangePersonalityType(currentUser.Id, personalityType);
return(Ok());
}
catch (IMPAException e)
{
return(BadRequest(new ErrorResult(e.GetType().Name, e.Message)));
}
}
public ReptilePython()
{
float randTail = Random.Range(23f, 33f);
tailLength = randTail;
int randHP = Random.Range(5, 25);
hitPoints = randHP;
float randWeight = Random.Range(27, 200);
weight = randWeight;
venomous = false;
PersonalityType randPersonality = (PersonalityType)Random.Range(0, 4);
personality = randPersonality;
}
public ReptileIguana()
{
float randTail = Random.Range(1, 5f);
tailLength = randTail;
int randHP = Random.Range(5, 10);
hitPoints = randHP;
float randWeight = Random.Range(3, 31);
weight = randWeight;
venomous = true;
PersonalityType randPersonality = (PersonalityType)Random.Range(0, 4);
personality = randPersonality;
}
public ReptileAlligator()
{
float randTail = Random.Range(7f, 7.5f);
tailLength = randTail;
int randHP = Random.Range(50, 55);
hitPoints = randHP;
float randWeight = Random.Range(100f, 500f);
weight = randWeight;
venomous = false;
PersonalityType randPersonality = (PersonalityType)Random.Range(0, 4);
personality = randPersonality;
}
public IHttpActionResult DeletePersonalityType(int id)
{
PersonalityType personalitytype = DataRepository.PersonalityType.Get(id);
if (personalitytype == null)
{
return(NotFound());
}
try
{
DataRepository.PersonalityType.Delete(personalitytype);
}
catch (Exception ex)
{
//string message = ExceptionHelper.GetMessageRecursively(ex);
string message = ex.GetMessageRecursively();
return(BadRequest(message));
}
return(Ok(personalitytype));
}
/// <summary>
/// Gets the Advantage/Disadvantage value for two personality types.
/// Returns 1 if P1 is advantaged, -1 if P1 is disadvantaged, and 0 if P1 and P2 are equally advantaged
/// </summary>
/// <param name="pt1">Personality 1</param>
/// <param name="pt2">Personality 2</param>
/// <returns>1 if P1 is advantaged -1 if P1 is disadvantaged 0 if P1 and P2 are equally advantaged</returns>
public int GetPersonalityTypeAdvantageValue(PersonalityType pt1, PersonalityType pt2)
{
// Advantaged
if ((pt1 == PersonalityType.RESOLUTE && pt2 == PersonalityType.QUIRKY) ||
(pt1 == PersonalityType.RECKLESS && pt2 == PersonalityType.RESOLUTE) ||
(pt1 == PersonalityType.QUIRKY && pt2 == PersonalityType.OBSERVANT) ||
(pt1 == PersonalityType.OBSERVANT && pt2 == PersonalityType.RECKLESS))
{
return(1);
}
// Disadvantaged
else if ((pt2 == PersonalityType.RESOLUTE && pt1 == PersonalityType.QUIRKY) ||
(pt2 == PersonalityType.RECKLESS && pt1 == PersonalityType.RESOLUTE) ||
(pt2 == PersonalityType.QUIRKY && pt1 == PersonalityType.OBSERVANT) ||
(pt2 == PersonalityType.OBSERVANT && pt1 == PersonalityType.RECKLESS))
{
return(-1);
}
// Equal
else
{
return(0);
}
}
/// <summary>
/// 性格生成
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
public static Personality CreatePresonality(PersonalityType type)
{
Personality personality = null;
switch (type)
{
case PersonalityType.Lonely: personality = new Personality("さみしがり", type, CharaStatusType.PhysicsAttack, CharaStatusType.PhysicsDamage); break;
case PersonalityType.Adamant: personality = new Personality("いじっぱり", type, CharaStatusType.PhysicsAttack, CharaStatusType.SpecialAttack); break;
case PersonalityType.Naughty: personality = new Personality("やんちゃ", type, CharaStatusType.PhysicsAttack, CharaStatusType.SpecialDamage); break;
case PersonalityType.Brave: personality = new Personality("ゆうかん", type, CharaStatusType.PhysicsAttack, CharaStatusType.Speed); break;
case PersonalityType.Bold: personality = new Personality("ずぶとい", type, CharaStatusType.PhysicsDamage, CharaStatusType.PhysicsAttack); break;
case PersonalityType.Impish: personality = new Personality("わんぱく", type, CharaStatusType.PhysicsDamage, CharaStatusType.SpecialAttack); break;
case PersonalityType.Lax: personality = new Personality("のうてんき", type, CharaStatusType.PhysicsDamage, CharaStatusType.SpecialDamage); break;
case PersonalityType.Relaxed: personality = new Personality("のんき", type, CharaStatusType.PhysicsDamage, CharaStatusType.Speed); break;
case PersonalityType.Modest: personality = new Personality("ひかえめ", type, CharaStatusType.SpecialAttack, CharaStatusType.PhysicsAttack); break;
case PersonalityType.Mild: personality = new Personality("おっとり", type, CharaStatusType.SpecialAttack, CharaStatusType.PhysicsDamage); break;
case PersonalityType.Rash: personality = new Personality("うっかりや", type, CharaStatusType.SpecialAttack, CharaStatusType.PhysicsDamage); break;
case PersonalityType.Quiet: personality = new Personality("れいせい", type, CharaStatusType.SpecialAttack, CharaStatusType.Speed); break;
case PersonalityType.Calm: personality = new Personality("おだやか", type, CharaStatusType.PhysicsDamage, CharaStatusType.PhysicsAttack); break;
case PersonalityType.Gentle: personality = new Personality("おとなしい", type, CharaStatusType.PhysicsDamage, CharaStatusType.PhysicsDamage); break;
case PersonalityType.Careful: personality = new Personality("しんちょう", type, CharaStatusType.PhysicsDamage, CharaStatusType.SpecialAttack); break;
case PersonalityType.Sassy: personality = new Personality("なまいき", type, CharaStatusType.PhysicsDamage, CharaStatusType.Speed); break;
case PersonalityType.Timid: personality = new Personality("おくびょう", type, CharaStatusType.Speed, CharaStatusType.PhysicsAttack); break;
case PersonalityType.Hasty: personality = new Personality("せっかち", type, CharaStatusType.Speed, CharaStatusType.PhysicsDamage); break;
case PersonalityType.Jolly: personality = new Personality("ようき", type, CharaStatusType.Speed, CharaStatusType.SpecialAttack); break;
case PersonalityType.Naive: personality = new Personality("むじゃき", type, CharaStatusType.Speed, CharaStatusType.SpecialDamage); break;
case PersonalityType.Bashful: personality = new Personality("てれや", type, CharaStatusType.Hp, CharaStatusType.Hp); break;
case PersonalityType.Hardy: personality = new Personality("がんばりや", type, CharaStatusType.Hp, CharaStatusType.Hp); break;
case PersonalityType.Docile: personality = new Personality("すなお", type, CharaStatusType.Hp, CharaStatusType.Hp); break;
case PersonalityType.Quirky: personality = new Personality("きまぐれ", type, CharaStatusType.Hp, CharaStatusType.Hp); break;
case PersonalityType.Serious: personality = new Personality("まじめ", type, CharaStatusType.Hp, CharaStatusType.Hp); break;
default: break;
}
return(personality);
}
private PersonalityTypeViewModel(PersonalityType type)
{
this.Type = type;
this.DisplayText = PersonalityTypeResources.ResourceManager.GetString(type.ToString() + "DisplayText");
}
void PopulatePersonality(string dump){ print (dump);
JSONObject json = new JSONObject (dump);
JSONObject personalitytypes = json ["personality_types"] ;
int total = personalitytypes.Count;
pt = new PersonalityType[7];
for (int i=0; i<total; i++) {
pt[i] = new PersonalityType();
JSONObject eachjson = personalitytypes[i];
print (eachjson["score"]);
pt[i].score = eachjson["score"].n;
JSONObject personalitytype = eachjson["personality_type"];
pt[i].name = personalitytype["name"].str;
pt[i].desc = personalitytype["description"].str;
JSONObject badge = personalitytype["badge"];
pt[i].badgeImageURL = badge["image_large"].str;
//TODO StartCoroutine(wwwget.FetchDataTexture(pt[i].badgeImageURL,AssignBadgeImage));
pt[i].keywords = personalitytype["keywords"].str;
}
es = ExamState.TypeLoaded;
}
public static Descriptor GetPersonalityDescriptor(PersonalityType personalityType, bool high)
{
//same index is used for Adjectives, nouns, adverbs ect
Pair<bool, PersonalityType> key = new Pair<bool, PersonalityType>(high, personalityType);
Descriptor d = descriptors [key] [UnityEngine.Random.Range (0, descriptors [key].Count)];
return d;//return a random descriptor in the r
}
