public CustomizeCharacter(int nexonSN, CharacterTemplate templete, Dictionary <string, int> defaultItem, List <int> unlockSlot)
{
this.NexonSN = nexonSN;
this.Templete = templete;
this.DefaultItem = defaultItem;
this.UnlockSlot = unlockSlot;
}
//unregistered character sheet, character sheet template -> unregistered character sheet of template
CharacterSheet SetCharacterValues(CharacterSheet hotSheet, CharacterTemplate hotTemplate)
{
//Set name and update game object
hotSheet.fullName = hotTemplate.fullName;
hotSheet.stringID = string.Format("{0:00} {1}", hotSheet.characterID, hotSheet.fullName);
hotSheet.gameObject.name = hotSheet.stringID;
//Assign Colors
hotSheet.primaryColor = hotTemplate.primaryColor;
hotSheet.secondaryColor = hotTemplate.secondaryColor;
hotSheet.skinColor = hotTemplate.skinColor;
//Assign Stats
hotSheet.toughness = hotTemplate.characterStatProfile.toughness;
hotSheet.currentFocus = hotTemplate.characterStatProfile.focus;
hotSheet.baseMuscle = hotTemplate.characterStatProfile.muscle;
hotSheet.baseBrawl = hotTemplate.characterStatProfile.brawl;
hotSheet.baseMelee = hotTemplate.characterStatProfile.muscle;
hotSheet.baseShot = hotTemplate.characterStatProfile.shot;
hotSheet.baseEvasion = hotTemplate.characterStatProfile.evasion;
hotSheet.baseIntelligence = hotTemplate.characterStatProfile.intelligence;
hotSheet.basePresence = hotTemplate.characterStatProfile.presence;
return(hotSheet);
}
public override void Init(CharacterTemplate chr)
{
var xhit = Physics2D.Raycast(chr.transform.position, chr.transform.right, distanceFromPlayer, 1 << LayerMask.NameToLayer("Ground"));
if (!xhit)
{
var pos = chr.transform.position + chr.transform.right * distanceFromPlayer;
var yhit = Physics2D.Raycast(pos, -transform.up, maxCastHeight, 1 << LayerMask.NameToLayer("Ground"));
if (yhit)
{
transform.position = new Vector2(pos.x, yhit.transform.position.y);
direction = transform.up;
targetTag = chr.GetComponent <PlayerController>() ? "Enemy" : "Player";
}
else
{
Destroy(gameObject);
}
}
else
{
Destroy(gameObject);
}
}
public async Task <int> UpdateAsync(CharacterTemplate character)
{
_context.Attach(character).State = EntityState.Modified;
int changes = await _context.SaveChangesAsync();
return(await Task.FromResult(changes));
}
public async Task <int> CreateAsync(CharacterTemplate character)
{
_context.Characters.Add(character);
int changes = await _context.SaveChangesAsync();
return(await Task.FromResult(changes));
}
public override void Init(CharacterTemplate chr)
{
//var player = FindObjectOfType<PlayerController>().transform;
//transform.parent = player;
player = chr.GetComponent <PlayerController>();
base.Init(chr);
}
// Finds the nearest PC;
public void FindNearestPC()
{
// Initially set distance to a high number.
nearestPCDistance = Mathf.Infinity;
foreach (GameObject PC in pcList)
{
playerCharTemp = PC.GetComponent <CharacterTemplate>();
if (playerCharTemp.isDead == false)
{
// Grabs the distance between this enemy and a PC in the array.
float distance = Vector3.Distance(transform.position, PC.transform.position);
if (distance < nearestPCDistance)
{
nearestPC = PC;
nearestPCDistance = distance;
}
MoveToNearestPC();
}
else
{
Debug.Log("NO TARGET");
StopUnit();
}
}
}
private static void ApplyMutations(CharacterTemplate buildTemplate, List <MLNode> mutationNodes)
{
if (!buildTemplate.genotypeEntry.IsMutant)
{
return;
}
Mutations part = buildTemplate.PlayerBody.GetPart <Mutations>();
foreach (MLNode node in mutationNodes)
{
if (node.Entry != null && node.Selected > 0)
{
if (node.Entry.Mutation != null)
{
BaseMutation baseMutation = node.Entry.CreateInstance();
baseMutation.SetVariant(node.Variant);
part.AddMutation(baseMutation, node.Selected);
}
else if (node.Entry.DisplayName == "Chimera")
{
buildTemplate.MutationLevel = "Chimera";
}
else if (node.Entry.DisplayName == "Esper")
{
buildTemplate.MutationLevel = "Esper";
}
}
}
}
public override void OnEnter()
{
base.OnEnter();
this.target = this.parent.GetTarget();
this.currTime = this.CoolDown;
}
public static void DrawSpawn(MapSpawnValues spawn, ISpriteBatch spriteBatch, IDrawableMap map, Font font)
{
var spawnArea = spawn.SpawnArea;
// Only draw if it does not cover the whole map
if (!spawnArea.X.HasValue && !spawnArea.Y.HasValue && !spawnArea.Width.HasValue && !spawnArea.Height.HasValue)
{
return;
}
// Draw spawn area
Vector2 cameraOffset = map.Camera.Min;
Rectangle rect = spawnArea.ToRectangle(map);
rect.X -= (int)cameraOffset.X;
rect.Y -= (int)cameraOffset.Y;
RenderRectangle.Draw(spriteBatch, rect, new Color(0, 255, 0, 75), new Color(0, 0, 0, 125), 2);
// Draw name
CharacterTemplate charTemp = CharacterTemplateManager.Instance[spawn.CharacterTemplateID];
if (charTemp != null)
{
string text = string.Format("{0}x {1} [{2}]", spawn.SpawnAmount, charTemp.TemplateTable.Name, spawn.CharacterTemplateID);
Vector2 textPos = new Vector2(rect.X, rect.Y);
textPos -= new Vector2(0, font.MeasureString(text).Y);
textPos = textPos.Round();
spriteBatch.DrawStringShaded(font, text, textPos, Color.White, Color.Black);
}
}
private void WriteClass(CharacterTemplate a)
{
writer.Write(a.ID);
writer.Write(a.Name);
writer.Write(a.Description);
writer.Write(a.HPperVIT);
writer.Write(a.MPperINT);
writer.Write(a.HPperLVL);
writer.Write(a.MPperLVL);
writer.Write((int)a.DamageStat);
WriteDictionary(a.BaseStats);
writer.Write(a.SkillTree.Entries.Count);
foreach (SkillTreeEntry e in a.SkillTree.Entries)
{
WriteSkillTreeEntry(e);
}
writer.Write(a.StarterEquipment.Length);
for (int i = 0; i < a.StarterEquipment.Length; i++)
{
if (a.StarterEquipment[i] == null)
{
writer.Write("null");
}
else
{
writer.Write(a.StarterEquipment[i].ID);
}
}
}
//Function to select next PC.
public void SelectNextPC()
{
moveScript = currentPC.GetComponent <MoveToClickPoint>();
moveScript.SetCharacterInactive();
currentPCIndex++;
if (currentPCIndex == pcList.Length)
{
currentPCIndex = 0;
}
currentPC = pcList[currentPCIndex];
playerCharTemp = currentPC.GetComponent <CharacterTemplate>();
while (playerCharTemp.isDead == true)
{
// ** BUG ** DEAD GUY STILL GETS SELECTED;
// ** NEED TO CHECK LOSE CONDITION HERE **
currentPCIndex++;
if (currentPCIndex == pcList.Length)
{
currentPCIndex = 0;
}
currentPC = pcList[currentPCIndex];
playerCharTemp = currentPC.GetComponent <CharacterTemplate>();
}
moveScript = currentPC.GetComponent <MoveToClickPoint>();
moveScript.SetCharacterActive();
playerCamera.currentPCIndex = currentPCIndex;
playerCamera.currentPC = currentPC;
}
void Start()
{
foreach (GameObject portrait in GameObject.FindGameObjectsWithTag("Portrait"))
{
portraits.Add(portrait);
}
if (pcList == null)
{
UpdatePCList();
}
if (pcList.Length > 0)
{
for (int i = 3; i >= 0; i--)
{
Debug.Log("pc" + pcList.Length + " textures " + portraits.Count);
img = (RawImage)portraits[i].GetComponent <RawImage>();
target = pcList[i].GetComponent <CharacterTemplate>();
img.texture = (Texture)target.Portrait;
}
// img = (RawImage)portraits[0].GetComponent<RawImage>();
// img.texture = (Texture)text1;
// img = (RawImage)portraits[1].GetComponent<RawImage>();
// img.texture = (Texture)text2;
// img = (RawImage)portraits[2].GetComponent<RawImage>();
// img.texture = (Texture)text3;
// img = (RawImage)portraits[3].GetComponent<RawImage>();
// img.texture = (Texture)text4;
}
}
private bool AddCharacter(int newId = -1)
{
if (string.IsNullOrEmpty(charName.text))
{
return(false);
}
try
{
string name = charName.text.Trim();
int race = dicRace.Where(x => x.Value == charRace.options[charRace.value].text).FirstOrDefault().Key;
float move = (float)Convert.ToDouble(string.IsNullOrEmpty(charMove.text) ? "0" : charMove.text);
int id = newId == -1 ? (characters.Count > 0 ? characters.Select(x => x.id).Max() + 1 : 0) : newId;
bool enemy = charIsEnemy.isOn;
if (characters.Where(x => x.name == name).Count() > 0)
{
Debug.LogError("Character exist");
return(false);
}
if (!charIsEnemy.isOn && !AddLevelList(newId))
{
return(false);
}
CharacterTemplate newCharacter = new CharacterTemplate(id, name, race, move, enemy, characterLevels);
characters.Add(newCharacter);
}
catch (Exception ex)
{
Debug.LogError(ex.Message);
return(false);
}
return(true);
}
private void LoadCharacter(string id)
{
CharacterTemplate temp = characters.Where(x => x.id.ToString() == id).First();
if (temp != null)
{
charId = temp.id;
charName.text = temp.name;
charRace.value = charRace.options.FindIndex(x => x.text == dicRace[(int)temp.race]);
charMove.text = temp.move.ToString();
charIsEnemy.isOn = temp.enemy;
SetCharWeapon();
if (charIsEnemy.isOn)
{
characterLevels = temp.levelData;
}
else
{
charLevel.text = temp.levelData[0].level.ToString();
charExp.text = temp.levelData[0].exp.ToString();
charHP.text = temp.levelData[0].hp.ToString();
charAtk.text = temp.levelData[0].atk.ToString();
charDef.text = temp.levelData[0].def.ToString();
charWis.text = temp.levelData[0].wis.ToString();
charDex.text = temp.levelData[0].dex.ToString();
charMdef.text = temp.levelData[0].mdef.ToString();
charGold.text = temp.levelData[0].gold.ToString();
charWeapon.value = charWeapon.options.FindIndex(x => x.text == dicWeapon[(int)temp.levelData[0].equipWeapon]);
charWeapon.RefreshShownValue();
}
ReloadCharacterLevel();
}
}
/// <summary>
/// Updates a CombatEntity using a given template.
/// </summary>
/// <param name="template">The template used to update the CombatEntity.</param>
/// <returns>Returns a read-only reference to the CombatEntity if the operation was successful. Else returns null.</returns>
public async Task <IReadOnlyCombatEntity> UpdateAsync(CharacterTemplate template)
{
if (!template.EntityId.HasValue)
{
return(null);
}
CombatEntity entity;
lock (_lock)
{
entity = _combatEntities.ContainsKey(template.EntityId.Value) ? _combatEntities[template.EntityId.Value] : null;
}
if (entity == null)
{
return(null);
}
var modified = await _combatEntityFactory.UpdateAsync(entity, template);
if (modified == null)
{
return(null);
}
lock (_lock)
{
_combatEntities[modified.Id] = modified;
}
return(modified);
}
/// <summary>
/// Updates an existing combat entity with the template given asynchronously.
/// <para>Will return null if the operation failed.</para>
/// </summary>
/// <param name="entity">The CombatEntity to update.</param>
/// <param name="template">The template to use to update the entity with.</param>
/// <returns>Returns the modified combat entity or null if no entity was modified.</returns>
public async Task <CombatEntity> UpdateAsync(CombatEntity entity, CharacterTemplate template)
{
if (!await IsValidTemplateAsync(template))
{
return(null);
}
var hairData = await _characterHairRepo.GetDataAsync();
var baseData = await _characterBaseRepo.GetDataAsync();
try
{
// Find the corresponding iconUris and arrange them in the correct order
var hair = hairData.First(h => h.Id == template.HairId).IconUri;
entity.IconUris.HairIconUri = hair;
}
catch (ArgumentException e)
{
Console.WriteLine(e.Message);
return(null);
}
entity.Name = template.Name;
entity.GroupId = template.GroupId;
entity.GrowthPoints = template.AllocatedStats;
return(entity);
}
public void TestNextRoundInitiative()
{
int periE = 33;
int persE = 13;
//Emptied peripheral
CharacterTemplate basicTemplate = new CharacterTemplate("Test", 5, periE, persE);
Character participantOne = new Character("Lucy", basicTemplate);
Character participantTwo = new Character("Sabo", basicTemplate);
CombatController cc = new CombatController();
cc.AddCharacter(participantOne);
cc.AddCharacter(participantTwo);
participantOne.CurrentInitiative = 5;
participantTwo.CurrentInitiative = 10;
cc.NextRound();
String[] expected = { "Sabo", "Lucy" };
Assert.AreEqual(0, cc.initiativeList.IndexOfValue(expected[0]));
Assert.AreEqual(1, cc.initiativeList.IndexOfValue(expected[1]));
participantTwo.CurrentInitiative = 5;
participantOne.CurrentInitiative = 10;
cc.NextRound();
Assert.AreEqual(1, cc.initiativeList.IndexOfValue(expected[0]));
Assert.AreEqual(0, cc.initiativeList.IndexOfValue(expected[1]));
}
public Character CreateCharacter(string code, object[] stats)
{
String name = (String)stats[0];
int essence = (int)stats[1];
int willpower = (int)stats[2];
List <String> healthLevels = (List <String>)stats[3];
Boolean isBattlegroup = (Boolean)stats[4];
String drill;
int size, might;
int persE = CalculatePersonalEssence(code, essence);
int periE = CalculatePeripheralEssence(code, essence);
if (!isBattlegroup)
{
CharacterTemplate template = new CharacterTemplate(code, essence, willpower, periE, persE, healthLevels, false);
Character newChar = new Character(name, template);
return(newChar);
}
else
{
drill = (String)stats[5];
size = (int)stats[6];
might = (int)stats[7];
CharacterTemplate template = new CharacterTemplate(code, essence, willpower, periE, persE, healthLevels, true);
Battlegroup battleGroup = new Battlegroup(name, template, might, size, drill);
return(battleGroup);
}
}
public Player(CharacterTemplate CharacterClass, List <ModularAbility> skills)
{
this.Equipment = (Items.ItemEquip[])CharacterClass.StarterEquipment.Clone();
this.Inventory = new Items.Inventory(64);
foreach (KeyValuePair <string, float> basestat in CharacterClass.BaseStats)
{
this.StatBonuses.Add(new StatBonus()
{
FlatValue = basestat.Value, Type = basestat.Key, Order = StatBonus.StatOrder.Template
});
}
this.StatBonuses.Add(new StatBonus()
{
FlatValue = 100, Type = "MP", Order = StatBonus.StatOrder.Template
});
this.SkillTree = CharacterClass.SkillTree;
this.Camera.Distance = 15;
this.Gravity = false;
this.JumpStrength = 10;
this.MaxJumps = 2;
this.Abilities = new List <ModularAbility>();
foreach (SkillTreeEntry e in CharacterClass.SkillTree.Entries)
{
List <ModularAbility> found = skills.Where(x => x.ID == e.SkillID).ToList();
if (found.Count != 1)
{
continue;
}
this.Abilities.Add(found[0]);
}
LearnFromTree();
}
public virtual void Init(CharacterTemplate chr)
{
//Debug.DrawRay(chr.transform.position, transform.right,Color.red,2f);
targetTag = chr.GetComponent <PlayerController>() ? "Enemy" : "Player";
transform.position = chr.transform.position + (offset * chr.transform.right);
direction = chr.transform.right;
}
public virtual void Picked(CharacterTemplate _char)
{
this.playerScore.value += this.ItemScore;
this.OnScoreChange.Raise();
ObjectManager.instance.Destroy(gameObject);
parent.Picked();
}
public override void OnEnter()
{
base.OnEnter();
this.target = this.parent.GetTarget();
this.parent.GetAnimator().SetFloat("Speed", 1f);
this.parent.SetSpeed(this.parentSpeedOnEnter);
}
public CreateCharacter(string nexonID, int nexonSN, string name, CharacterTemplate template, bool isCheat, bool usePreset, bool isPremium)
{
this.NexonID = nexonID;
this.NexonSN = nexonSN;
this.Name = name;
this.Template = template;
this.IsCheat = isCheat;
this.UsePreset = usePreset;
this.IsPremium = isPremium;
}
private void classlist_DoubleClick(object sender, EventArgs e)
{
if (classlist.SelectedItems.Count != 1)
{
return;
}
CurrentClass = (CharacterTemplate)classlist.SelectedItem;
EditCurrentClass();
panel1.Refresh();
}
void Reset()
{
controller = new CharacterTemplate ();
controller.animator = GetComponent<Animator> ();
characterController = GetComponent<CharacterController> ();
characterController.center = Vector3.up * 0.75f;
characterController.height = 1.5f;
characterController.radius = 0.3f;
}
// Public Methods
public async Task <CharacterTemplate> ReadAsync(int?id)
{
if (id == null)
{
return(null);
}
CharacterTemplate character = await _context.CharacterTemplates.FirstOrDefaultAsync(m => m.Id == id);
return(await Task.FromResult(character));
}
private CharacterTemplate ReadClass1()
{
CharacterTemplate result = CharacterTemplate.CreateEmpty(reader.ReadString());
result.Name = reader.ReadString();
result.Description = reader.ReadString();
result.HPperVIT = reader.ReadInt32();
result.MPperINT = reader.ReadInt32();
result.HPperLVL = reader.ReadInt32();
result.MPperLVL = reader.ReadInt32();
CharacterTemplate.Attrubutes setstat;
switch (reader.ReadInt32())
{
case 0:
{
setstat = CharacterTemplate.Attrubutes.STR;
break;
}
case 1:
{
setstat = CharacterTemplate.Attrubutes.DEX;
break;
}
case 2:
default:
{
setstat = CharacterTemplate.Attrubutes.INT;
break;
}
}
result.DamageStat = setstat;
result.ArmourPreference = (CharacterTemplate.ArmourTypes)reader.ReadInt32();
result.WeaponPreferenceIDs = ReadListOfString();
result.BaseStats = ReadDictionary();
int skillcount = reader.ReadInt32();
for (int i = 0; i < skillcount; i++)
{
result.SkillTree.Entries.Add(ReadSkillTreeEntry());
}
List <string> invnentoryIDs = new List <string>();
int inventorycount = reader.ReadInt32();
for (int i = 0; i < inventorycount; i++)
{
invnentoryIDs.Add(reader.ReadString());
}
return(result);
}
/// <summary>
/// Creates and returns a CombatEntity from a given template.
/// </summary>
/// <param name="template">The template used to insert spawn the CombatEntity.</param>
/// <returns>Returns a read-only reference to the CombatEntity if the operation was successful. Else returns null.</returns>
public async Task <IReadOnlyCombatEntity> CreateAsync(CharacterTemplate template)
{
var entity = await _combatEntityFactory.CreateAsync(template);
lock (_lock)
{
_combatEntities.Add(entity.Id, entity);
}
return(entity);
}
public override void Picked(CharacterTemplate _char)
{
WeaponTemplate weapon = _char.GetWeapon();
if (weapon != null)
{
weapon.AddBullet(this.bulletAmount);
base.Picked(_char);
}
}
public override void Picked(CharacterTemplate _char)
{
if (_char.IsFullHealth())
{
return;
}
_char.AddHealth(this.healthAmount);
base.Picked(_char);
}
void OnGUI()
{
if (!skin) skin = Resources.Load("skin") as GUISkin;
GUI.skin = skin;
this.minSize = rect;
this.titleContent = new GUIContent("Character", null, "3rd Person Character Creator");
if (templateNames == null) templateNames = new List<string>();
if (templates == null) return;
foreach (CharacterTemplate template in templates)
{
if (!templateNames.Contains(template.name))
templateNames.Add(template.name);
}
GUILayout.BeginVertical ("box");
if (templates.Count > 0)
{
EditorGUILayout.Space();
GUILayout.BeginHorizontal("box");
selectedTemplate = EditorGUILayout.Popup("Character Template", selectedTemplate, templateNames.ToArray());
GUILayout.EndHorizontal();
currentTemplate = templates[selectedTemplate];
}
else
{
EditorGUILayout.HelpBox("Can't find a Character Template\nPlease create Template in\n3rd Person Controller>Resources>New Character Template ", MessageType.Error);
}
var currentEvent = Event.current;
buttomRect = GUILayoutUtility.GetLastRect();
buttomRect.position = new Vector2(0, buttomRect.position.y);
buttomRect.width = this.maxSize.x;
if (buttomRect.Contains(currentEvent.mousePosition) || templates == null)
{
templates = new List<CharacterTemplate>();
LoadAllAssets(Application.dataPath, ref templates);
}
if (!isValidTemplate())
{
EditorGUILayout.HelpBox("The Character Template is null or incomplete", MessageType.Error);
GUILayout.EndVertical ();
GUILayout.FlexibleSpace();
return;
}
if (!charObj)EditorGUILayout.HelpBox("Make sure your FBX model is select as Humanoid!",MessageType.Info);
else
if (!charExist) {
EditorGUILayout.HelpBox ("Missing a Animator Component", MessageType.Error);
} else if (!isHuman)
EditorGUILayout.HelpBox ("This is not a Humanoid", MessageType.Error);
else if (!isValidAvatar)
EditorGUILayout.HelpBox (charObj.name + " is a invalid Humanoid", MessageType.Info);
GUILayout.BeginHorizontal("box");
charObj = EditorGUILayout.ObjectField("FBX Model", charObj, typeof(GameObject), true, GUILayout.ExpandWidth(true)) as GameObject;
if (GUI.changed && charObj !=null)
humanoidpreview = Editor.CreateEditor(charObj);
GUILayout.EndHorizontal();
EditorGUILayout.Space();
if(charObj)
charAnimator = charObj.GetComponent<Animator>();
charExist = charAnimator != null;
isHuman = charExist?charAnimator.isHuman:false;
isValidAvatar = charExist?charAnimator.avatar.isValid:false;
if (CanCreate ())
{
DrawHumanoidPreview ();
GUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
if (GUILayout.Button ("Create"))
Create ();
GUILayout.FlexibleSpace();
GUILayout.EndHorizontal();
}
EditorGUILayout.Space();
GUILayout.EndVertical ();
}
