public void get_Experiencia_Oficio(TcpClient cliente, string paquete)
{
string[] separador_oficio_experiencia = paquete.Substring(3).Split('|');
GameCharacter personaje = cliente.Account.Game.Character;
uint experiencia_actual, experiencia_base, experiencia_siguiente_nivel;
short id;
byte nivel;
foreach (string oficio in separador_oficio_experiencia)
{
id = short.Parse(oficio.Split(';')[0]);
nivel = byte.Parse(oficio.Split(';')[1]);
experiencia_base = uint.Parse(oficio.Split(';')[2]);
experiencia_actual = uint.Parse(oficio.Split(';')[3]);
if (nivel < 100)
{
experiencia_siguiente_nivel = uint.Parse(oficio.Split(';')[4]);
}
else
{
experiencia_siguiente_nivel = 0;
}
personaje.oficios.Find(x => x.id == id).set_Actualizar_Oficio(nivel, experiencia_base, experiencia_actual, experiencia_siguiente_nivel);
}
personaje.evento_Oficios_Actualizados();
}
public Bow(GameplayScreen gameplayScreen, GameCharacter owner)
: base(gameplayScreen, owner)
{
_arrow = new Arrow(ImageManager.ArrowTexture);
coolDownTime = 1.5;
coolDownElapsed = 0;
}
public void SetStartingCharacter(GameCharacter character)
{
if (isRunningGameLoop == false)
{
_activeCharacter = character;
}
}
/// <summary>
/// Событие происходящее раз в пол года
/// Проверка выполнения плана
/// </summary>
private void ImplementationPlan()
{
if (_currentJob.Plan <= _currentJob.WorkPlan)
{
GameCharacter.Set("Money", _currentJob.Salary_End * 2);
TopMostMessageBox.Show("Вы выполнили план. В качестве премии вам начислили " + (_currentJob.Salary_End * 2).ToString() + " $", "Событие");
}
else
{
var randomValue = random.Next(0, 4);
if (randomValue == 0)
{
QuitWork_Click(new object(), new EventArgs());
TopMostMessageBox.Show("Вы не выполнили план и поэтому вас уволили с работы", "Событие");
}
else
{
TopMostMessageBox.Show("Вы не выполнили план", "Событие");
}
}
_currentJob.WorkPlan = 0;
TextOutput(labelWorkPlan, "Выполнение плана: 0%");
}
public void RemoveCharacter(GameCharacter c)
{
if (_characters.Contains(c))
{
_characters.Remove(c);
}
}
private void OnTriggerEnter2D(Collider2D collision)
{
if (collision.CompareTag("Player"))
{
collision.GetComponent <PlayerController>().receiveDamage(power);
if (!isBouncing)
{
Destroy(gameObject);
}
}
else if (GameCharacter.collidingWithObstacle(collision) && !throughWalls)
{
if (isBouncing)
{
bounce();
}
else if (nOfProjectilesOnBounce > 0)
{
bounceSpawn();
}
else
{
Destroy(gameObject);
}
}
}
public void actOn(GameCharacter actingCharacter)
{
Audio.playSound("stairs");
Engine.Engine.NextLevel();
calledNextLevel = true;
Audio.playRandomSong();
}
/// <summary>
/// Событие происходящие в конце дня
/// </summary>
/// <param name="sender"></param>
/// <param name="even"></param>
private void GetValue_Everyday(object sender, PropertyChangedEventArgs even)
{
if (_currentStudy != null)
{
countMonth += 1;
Event_Study();
_currentStudy.StudyPlan += Effort_Study.ReturnValue();
TextOutput(labelStudyPlan, "Выполнение плана: " + _currentStudy.StudyPlan + " %");
_currentStudy.PeriodStudy -= 1;
TextOutput(labelMonthsLeft, "Месяцев осталось: " + _currentStudy.PeriodStudy + " мес.");
if (countMonth >= 1)
{
countMonth = 0;
GameCharacter.Set("Intelligence", 1);
}
if (_currentStudy.PeriodStudy == 0)
{
ImplementationPlan();
}
}
}
public async Task <int> SaveDesignedCharacter(GameCharacter character, string userId)
{
var userCharacter = _context.UserCharacters.FirstOrDefault(m => m.CharacterName == character.Name && m.UserId == userId);
if (userCharacter != null)
{
var response = JsonConvert.DeserializeObject <GameCharacter>(userCharacter.CharacterDescription);
if (response.Properties?.FirstOrDefault(m => m?.Property == "Level")?.Value == character.Properties?.FirstOrDefault(m => m?.Property == "Level")?.Value)
{
return(2);
}
}
var characterDescription = JsonConvert.SerializeObject(character);
var gameCharacter = new UserCharacter()
{
CharacterType = character.CharacterName,
CharacterName = character.Name,
CharacterDescription = characterDescription,
UserId = userId
};
_context.UserCharacters.Add(gameCharacter);
var result = await _context.SaveChangesAsync();
return(result);
}
void Start()
{
_fight = Camera.main.GetComponent<FightController>();
_character = GlobalCharacter.player;
_children = transform.GetChild(0).gameObject;
SetCurrent(false);
}
private void Visit(GameCharacter gameCharacter)
{
if (Owner == null)
{
Visitor = null;
gameCharacter.Trade = null;
gameCharacter.Notify("Trade has been closed.", NoticeType.Popup);
}
else
{
Started = true;
using var pw = new PacketWriter(ServerOperationCode.PlayerInteraction);
pw.WriteByte(InteractionCode.Visit);
pw.WriteByte(1);
pw.WriteBytes(Visitor.AppearanceToByteArray());
pw.WriteString(Visitor.Name);
Owner.Send(pw);
using var pw2 = new PacketWriter(ServerOperationCode.PlayerInteraction);
pw2.WriteByte(InteractionCode.Room);
pw2.WriteByte(3);
pw2.WriteByte(2);
pw2.WriteByte(1);
pw2.WriteByte(0);
pw2.WriteBytes(Owner.AppearanceToByteArray());
pw2.WriteString(Owner.Name);
pw2.WriteByte(1);
pw2.WriteBytes(Visitor.AppearanceToByteArray());
pw2.WriteString(Visitor.Name);
pw2.WriteByte(byte.MaxValue);
Visitor.Send(pw2);
}
}
//DEPRECATED
public void toggleCharacter()
{
Debug.Log("toggling characters");
selectedCharIndex++;
if (selectedCharIndex > gameDataObject.partyList.Count)
{
selectedCharIndex = 0;
}
if (selectedCharIndex == 0)
{
selectedGameCharacter = gameDataObject.playerGameCharacter;
}
else if (gameDataObject.partyList.Count > 0 && selectedCharIndex <= gameDataObject.partyList.Count)
{
selectedGameCharacter = gameDataObject.partyList[selectedCharIndex - 1];
}
gameDataObject.SelectCharacter(selectedGameCharacter);
Debug.Log("Selected " + selectedGameCharacter.name);
dragAndDropScript.clearEquipment();
loadEquipment();
loadWeapon();
loadHotbar();
loadAmmo();
}
void OnTriggerExit2D(Collider2D collider)
{
if (target && collider.gameObject == target.gameObject)
{
target = null;
}
}
void Update()
{
if (target && !target.gameObject.activeSelf)
{
target = null;
}
}
void OnTriggerEnter2D(Collider2D collider)
{
if (collider.tag == "Player")
{
target = collider.GetComponent <GameCharacter>();
}
}
/// <summary>
/// True if Map is Passable. Game Option isCollisionMaskOn determines is pixel collision in on, if not Tile passability applies
/// </summary>
/// <param Name="x">X coordinate</param>
/// <param Name="y">Y coordinate</param>
/// <param Name="d">direction (0,2,4,6,8,10)</param>
/// <param Name="self_event">Self (If event is determined passable)</param>
public bool IsPassable(int x, int y, int d, GameCharacter self_event, bool automove)
{
// Event passability
byte bit = ObstableBit[d];
foreach (GameEvent e in Events)
{
if (e != null)
{
if (e.TileId >= 0 && e != self_event &&
e.X / 32 == x / 32 && (e.Y - 1) / 32 == (y - 1) / 32 && !e.Through)
{
if ((passages[e.TileId] & bit) != 0)
{
return(false);
}
else if ((passages[e.TileId] & 0x0f) == 0x0f)
{
return(false);
}
else if (priorities[e.TileId] == 0)
{
return(true);
}
}
}
}
// If coordinates given are outside of the map
if (!IsValid(x, y - 1))
{
return(false);
}
if (GameOptions.IsCollisionMaskOn)
{
return(IsPixelPassable(x, y, d, self_event));
}
else
{
if (GameOptions.IsTileByTileMoving)
{
// Move for automatic character move
if (automove)
{
return(IsTilePassable(x + 15, y + 20, d, self_event));
}
// Player and other moves
else
{
// If unable to enter move Tile in designated direction
return(IsTilePassable(x, y, d, self_event));
}
}
else
{
// If unable to enter move Tile in designated direction
return(IsTilePassable(x, y + 20, d, self_event));
}
}
}
public Gun(GameplayScreen gameplayScreen, GameCharacter owner)
: base(gameplayScreen, owner)
{
_bullet = new Bullet(ImageManager.BulletTexture);
coolDownTime = 0.8;
coolDownElapsed = 0;
}
public CommandOperationStatus Take(GameObject gameObject, GameCharacter gameCharacter)
{
var status = new CommandOperationStatus();
try
{
if (gameCharacter.HasIndirectRelationshipWith(gameObject, RelationshipType.IsHeldBy, RelationshipDirection.ParentToChild))
{
status.Message = gameCharacter.Name + " already has " + gameObject.Name;
status.Status = false;
return(status);
}
RemoveDirectPossessionRelationships(gameObject);
gameObject.AddRelationship(RelationshipType.IsHeldBy, RelationshipDirection.ChildToParent, gameCharacter);
status.Message = gameCharacter.Name + " took " + gameObject.Name;
status.Status = true;
}
catch (Exception e)
{
status.Message = e.Message;
status.Status = false;
}
return(status);
}
public void Init(GameCharacter _actorCharacter, AnimeAction _subAttackAction)
{
// mIsDone = false;
// Debug.Log("BattleVFXAction: Init called");
// mVFXObject = _vfxObj;
// mVFXName = vfxName;
actorCharacter = _actorCharacter;
subAttackAction = _subAttackAction;
actorCharacter.SetAnimeEventCallback((string eventName) => {
//Debug.Log("BattleVFXAction: animeEvent. name=" + eventName);
if (eventName == "attack")
{
//HitTarget();
StartSubAttackAction();
}
});
actorCharacter.SetAnimeEndCallback(() => {
//if(onAttackAction == null || onA
MarkAsDone();
});
}
public CommandOperationStatus Drop(GameObject gameObject, GameCharacter gameCharacter, GameLocation location)
{
var status = new CommandOperationStatus();
try
{
RemoveDirectPossessionRelationships(gameObject);
if (!gameCharacter.HasIndirectRelationshipWith(gameObject, RelationshipType.IsHeldBy, RelationshipDirection.ParentToChild))
{
status.Message = gameCharacter.Name + " doesn't have " + gameObject.Name;
status.Status = false;
return(status);
}
location.AddRelationship(RelationshipType.Contains, RelationshipDirection.ParentToChild, gameObject);
status.Message = gameCharacter.Name + " dropped " + gameObject.Name;
status.Status = true;
}
catch (Exception e)
{
status.Message = e.Message;
status.Status = false;
}
return(status);
}
public override void Execute(GameCharacter caller, string[] args)
{
if (args.Length < 2)
{
ShowSyntax(caller);
}
else
{
var message = args.Fuse(1);
switch (args[0].ToLower())
{
case "-map":
caller.Map.Send(GamePackets.Notify(message));
break;
case "-channel":
caller.Client.Server.Send(GamePackets.Notify(message));
break;
case "-world":
caller.Client.Server.World.Send(GamePackets.Notify(message));
break;
default:
ShowSyntax(caller);
break;
}
}
}
protected override void attack(string attacker)
{
// play sound
GM.PlayAudio(attackSound);
// Show muzzle flash
StartCoroutine(showMuzzleFlash());
// Raycast bullet
Vector2 firePos = firePoint.position;
Vector2 dir = (firePos - (Vector2)transform.position).normalized;
RaycastHit2D hit = Physics2D.Raycast(firePos, dir, range, whatToHit);
Vector3 normal = fakeNormal;
Vector3 hitPos = (dir * (range / 1)) + firePos;
if (hit.collider)
{
normal = hit.normal;
hitPos = hit.point;
Debug.DrawLine(firePos, hit.point, Color.red);
GameCharacter c = hit.collider.GetComponent <GameCharacter>();
if (c && (c.tag != "Player" || GM.instance.friendlyFire))
{
c.Hurt(attackDamage, attacker);
c.KnockBack(dir * attackKnockBack);
ZombieAI ai = c.GetComponent <ZombieAI>();
if (ai)
{
ai.SetTarget(transform);
}
}
}
showEffect(hitPos, normal);
}
// Set character
protected virtual void SetCharacter(GamePlayer player, int toIndex)
{
// Ignore invalid player
if (player == null)
{
return;
}
// Ignore invalid character
if (toIndex < 0 || toIndex >= GameManager.instance.gameData.characters.Length)
{
return;
}
// Get character & set index
GameCharacter character = GameManager.instance.gameData.characters[toIndex];
player.characterIndex = toIndex;
// Set character name
if (characterNameLabel != null)
{
characterNameLabel.text = character.characterName;
}
// Set character texture
if (characterIcon != null)
{
SetCharacterIcon(characterIcon, character.characterIconTexture);
}
}
// Load game textures
private void LoadGameTextures()
{
if (gameData != null)
{
if (gameData.characters != null)
{
for (int c = 0; c < gameData.characters.Length; c++)
{
GameCharacter character = gameData.characters[c];
if (!string.IsNullOrEmpty(character.characterIconPath) && character.characterIconTexture == null)
{
LoadTexture(character.characterIconPath, delegate(Texture2D texture)
{
character.characterIconTexture = texture;
});
}
}
}
if (gameData.colors != null)
{
for (int c = 0; c < gameData.colors.Length; c++)
{
GameColor color = gameData.colors[c];
if (color.colorBorderTexture == null)
{
LoadTexture(color.colorName + ".png", delegate(Texture2D texture)
{
color.colorBorderTexture = texture;
});
}
}
}
}
}
public bool PlaceInventory(Job job, GameCharacter character)
{
GameInventory sourceInventory = character.Inventory;
// Check that it's wanted by the job
if (job.RequestedItems.ContainsKey(sourceInventory.Type) == false)
{
UnityDebugger.Debugger.LogError(InventoryManagerLogChanel, "Trying to add inventory to a job that it doesn't want.");
return(false);
}
// Check that there is a target to transfer to
if (job.DeliveredItems.ContainsKey(sourceInventory.Type) == false)
{
job.DeliveredItems[sourceInventory.Type] = new GameInventory(sourceInventory.Type, 0, sourceInventory.MaxStackSize);
}
GameInventory targetInventory = job.DeliveredItems[sourceInventory.Type];
int transferAmount = Mathf.Min(targetInventory.MaxStackSize - targetInventory.StackSize, sourceInventory.StackSize);
sourceInventory.StackSize -= transferAmount;
targetInventory.StackSize += transferAmount;
CleanupInventory(character);
return(true);
}
void Start()
{
_fight = Camera.main.GetComponent <FightController>();
_character = GlobalCharacter.player;
_children = transform.GetChild(0).gameObject;
SetCurrent(false);
}
private IEnumerator ProcessPotentials(GameCharacter client, System.Action <GameUnit> result)
{
int currDist = 0;
int minDist = 100;
GameUnit min = null;
bool pingSuccessful = false;
foreach (GameCharacter target in targetPool)
{
yield return(StartCoroutine(PingTile(client, target.currTile, value => currDist = value)));
if (currDist > 0 && currDist < minDist)
{
minDist = currDist;
min = target;
}
foreach (GameUnitLink link in target.health.links)
{
yield return(StartCoroutine(PingTile(client, link.currTile, value => currDist = value)));
if (currDist > 0 && currDist < minDist)
{
minDist = currDist;
min = link;
}
}
yield return(null);
}
result(min);
}
public override void Execute(GameCharacter caller, string[] args)
{
if (args.Length == 0)
{
ShowSyntax(caller);
}
else
{
var name = args[0];
if (!(caller.Client.Server.World.GetCharacterByName(name) is GameCharacter target))
{
caller.Notify($"[Command] Character '{name}' could not be found.");
return;
}
if (target.Name == caller.Name)
{
caller.Notify("You cannot kick yourself");
return;
}
if (target.IsMaster)
{
caller.Notify("You cannot kick a GM");
return;
}
target.Client.Terminate($"Player was kicked by {caller.Name}");
}
}
public IHttpActionResult PutGameCharacter(int id, GameCharacter gameCharacter)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != gameCharacter.ID)
{
return(BadRequest());
}
db.Entry(gameCharacter).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!GameCharacterExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public Mist(Rectangle boundingBox, GameCharacter gameCharacter, Skill skill)
{
Skill = skill;
MistType = CalculateMistType();
Owner = gameCharacter;
Bounds = boundingBox;
}
public override void Execute(GameCharacter caller, string[] args)
{
if (args.Length > 1)
{
ShowSyntax(caller);
}
else
{
var drop = false;
if (args.Length == 1)
{
if (args[0].ToLower() == "-drop" || args[0].ToLower() == "-drops")
{
drop = true;
}
else
{
ShowSyntax(caller);
return;
}
}
lock (caller.Map.Mobs)
{
var toKill = caller.Map.Mobs.Values.ToList();
foreach (var loopMob in toKill)
{
loopMob.CanDrop = drop;
loopMob.Die();
}
}
}
}
//TODO: pass in the character to use to construct player ownership
public List <TalentTreeDisplayData> getTalentTreeDisplayData(GameCharacter gameCharacter)
{
List <TalentTreeDisplayData> talentTreeDisplayList = new List <TalentTreeDisplayData>();
foreach (var talentData in gameDataSet.talentTreeDataDictionary.Values)
{
var abilityData = gameDataSet.abilityDataDictionary[talentData.AbilityID];
bool playerOwned = (gameCharacter.abilityList.Where(x => x.ID == abilityData.ID).Count() > 0) ? true : false;
TalentTreeDisplayData tempTT = new TalentTreeDisplayData()
{
ID = talentData.ID,
AbilityID = abilityData.ID,
AbilityDescription = abilityData.description,
AbilityName = abilityData.name,
SpriteSheetName = abilityData.sheetname,
SpriteSheetIndex = abilityData.spriteindex,
AP = abilityData.ap,
levelReq = talentData.levelReq,
owned = playerOwned,
unlocked = getPlayerUnlocked(gameCharacter, talentData.levelReq, talentData.abilityReqs),
range = abilityData.range,
tag = talentData.tag,
targetType = abilityData.targetType,
tier = talentData.tier,
uses = abilityData.cooldown,
tilePatternType = abilityData.tilePatternType,
abilityReqNameList = getAbilityNameList(talentData.abilityReqs),
effectDescriptionList = getEffectsDescriptionList(abilityData.passiveEffects, abilityData.activeEffects)
};
talentTreeDisplayList.Add(tempTT);
}
return(talentTreeDisplayList);
}
public void AssignController()
{
if (Controller != null)
{
// Already has a controller
return;
}
var leastControlled = int.MaxValue;
GameCharacter newController = null;
lock (Map.Characters)
{
foreach (var character in Map.Characters.Values.Where(x => x.Client.Connected))
{
if (character.ControlledNpcs.Count >= leastControlled)
{
continue;
}
leastControlled = character.ControlledNpcs.Count;
newController = character;
}
}
newController?.ControlledNpcs.Add(this);
}
// Use this for initialization
void Start()
{
floorMask = LayerMask.GetMask("Floor");
m_AttackMode = 0;
m_CastType = 0;
m_Character = GetComponent<GameCharacter>();
m_Caster = GetComponent<MagicAttackCaster>();
}
public void actOn(GameCharacter actingCharacter)
{
if (actingCharacter == null)
{
changeSolid();
Audio.playSound("IronGate");
}
}
void Start()
{
if (isPlayer)
{
_character = GlobalCharacter.generetaChar();
_character.sprite = Random.Range(1, 4);
}
}
public static void UpdateTargets(GameCharacter newTarget)
{
foreach (Enemy e in GetAllEnemies())
{
if (e.IsAggro)
{
e.ForceAggro(newTarget);
}
}
}
public static void UpdateBossTargets(GameCharacter newTarget)
{
foreach (BossEnemy b in GetAllBosses())
{
if (b.IsAggro)
{
b.ForceAggro(newTarget);
}
}
}
private void AddCharToScene(GameCharacter value)
{
GameObject _itm = Instantiate(_charModel) as GameObject;
_itm.transform.position = _positions;
_itm.transform.parent = this.transform;
_itm.GetComponent<CharFightController>().SetCurrent(false);
_itm.GetComponent<CharFightController>().character = value;
charsFight = _itm;
}
// Use this for initialization
void Start () {
loadGameData();
InitPrefabs();
initScreens();
curGameCharacter = gameDataObject.playerGameCharacter;
UpdateUI();
UpdateTalentTags();
}
// Use this for initialization
void Start () {
loadGameData();
curGameCharacter = gameDataObject.playerGameCharacter;
initScreens();
InitPrefabs();
this.assetLibrary = gameDataObject.assetLibrary;
LoadCharacterStats();
ClearCurrentEquip();
}
public static GameCharacter generetaChar()
{
GameCharacter _char = new GameCharacter();
_char.baseAttr.SetAttributes(10, 10, 10, 10, 10, 100, 1000);
_char.baseAttr.SetTimers(10, 20, 5, 10);
_char.sprite = Random.Range(1, 5);
_char.itens.SetValue(GlobalItens.generateAlchemy(AlchemyType.HealLife), 0);
_char.itens.SetValue(GlobalItens.generateAlchemy(AlchemyType.HealLife), 1);
_char.itens.SetValue(GlobalItens.generateAlchemy(AlchemyType.HealLife), 2);
_char.itens.SetValue(GlobalItens.generateAlchemy(AlchemyType.HealLife), 3);
return _char;
}
public static void Init()
{
if (!_hasInit)
{
_player = generetaChar();
_player.name = "Character 1";
_player.sprite = 1;
_npcs = new ArrayList();
_enemies = new ArrayList();
for (int i = 0; i < 5; i++)
{
_enemies.Add(generetaChar());
}
_hasInit = true;
}
}
public void Awake()
{
switch (m_MakeAIType)
{
case eAIType.NORMAL_AI:
{
GameObject aiObject = new GameObject();
aiObject.name = m_MakeAIType.ToString("F");
m_AI = aiObject.AddComponent<NormalAI>();
aiObject.transform.SetParent(SelfTransform);
}
break;
default:
break;
}
m_AI.TargetComponent = this;
GameCharacter gameCharacter = CharacterMgr.Instance.AddCharacter(m_TemplateKey);
gameCharacter.TargetComponent = this;
m_SelfCharater = gameCharacter;
////--
// Actor -> Awake()
for (int i = 0; i < gameCharacter.CHRACTER_TEMPLATE.LIST_SKILL.Count; i++)
{
SkillData skillData = SkillMgr.Instance.GetSkillData(gameCharacter.CHRACTER_TEMPLATE.LIST_SKILL[i]);
gameCharacter.AddSkill(skillData);
}
if (m_bEnableBoard)
{
BaseBoard board = BoardMgr.Instance.AddBoard(this, eBoardType.BOARD_HP);
board.SetData("HP", GetFactorData(eFactorData.MAX_HP), m_SelfCharater.m_CurrentHP);
}
ActorMgr.Instance.AddActor(this);
}
protected int getCooldown(GameCharacter enemy)
{
return (enemy.health<= 0)? 0: abilityCooldown;
}
private static void Serialize()
{
IniFile file = new IniFile();
IniSection section = file.Sections.Add("User's Character");
GameCharacter character = new GameCharacter();
character.Name = "John";
character.Attack = 5.5;
character.Defence = 1;
character.Health = 75;
// Serialize GameCharacter object into section's keys.
section.Serialize(character);
// Deserialize section into GameCharacter object.
GameCharacter savedCharacter = section.Deserialize<GameCharacter>();
Console.WriteLine(section.Keys["Name"].Value);
Console.WriteLine(savedCharacter.Name);
Console.WriteLine(section.Keys["Sword"].Value);
Console.WriteLine(savedCharacter.Attack);
Console.WriteLine(section.Keys["Shield"].Value);
Console.WriteLine(savedCharacter.Defence);
}
/// <summary>
/// Converts damage input into the enemy to a lower damage based on this enemy's defense, and then deals it and calls Die() if health is less than 0
/// </summary>
/// <param name="damage">The damage the attacker dealt</param>
/// <param name="attacker">The GameCharacter that attacked this enemy (used for aggro)</param>
public override void TakeDamage(int damage, GameCharacter attacker)
{
Level level = Engine.Engine.currentLevel;
if (target == null)
{
target = attacker;
foreach (Enemy e in GetAllEnemies())
{
if(AStar.calculateHeuristic(level.CharacterEntities.FindPosition(this), level.CharacterEntities.FindPosition(e)) < 3)
{
e.ForceAggro(attacker);
}
}
}
float tempArmor = (float)defense / 100f;
if (attacker is Mage)
{
tempArmor /= 3;
}
damage -= (int)((float)damage * tempArmor);
health -= damage;
if (health <= 0)
{
health = 0;
Die();
}
}
public void StartTempTextOnChar(GameCharacter gameCharacter, int amount, bool isDamage)
{
Color c = Color.green;
if (isDamage)
{
c = Color.red;
}
Vector3 charPos = new Vector3(gameCharacter.x, -gameCharacter.y + 0.5f, 0);
battleGame.battleLog.AddEntry(charPos.ToString());
StartTempText(charPos, c, amount.ToString());
}
public void StartTempSpriteOnChar(GameCharacter gameCharacter, string spritesheet, int spriteindex)
{
Vector3 charPos = new Vector3(gameCharacter.x, -gameCharacter.y, 0);
StartTempSprite(charPos, charPos, spritesheet, spriteindex);
}
public void StartTempParticleOnChar(GameCharacter gameCharacter, string particleName)
{
Vector3 charPos = new Vector3(gameCharacter.x, -gameCharacter.y, 0);
StartTempParticles(particleName, charPos);
}
public void actOn(GameCharacter actingCharacter)
{
changeSolid();
}
public override void drawVisualEffect(GameCharacter hero, GameCharacter enemy)
{
Engine.Engine.AddVisualAttack(hero, enemy, "Hero/Whirlwind", .5f, 1.0f, .03f);
}
void Awake()
{
character = GetComponent<GameCharacter>();
}
public override void drawVisualEffect(GameCharacter hero, GameCharacter enemy)
{
Engine.Engine.AddVisualAttack(enemy, "Hero/hammerSmash", .5f, 1.0f, .03f);
}
public void ForceAggro(GameCharacter aTarget)
{
target = aTarget;
}
// Use this for initialization
void Start()
{
m_Monster = GetComponent<GameCharacter>();
}
//Load Character Avatar Sprite on Tile Map
private GameObject LoadCharacter(GameCharacter character)
{
GameObject characterObject = (GameObject)Instantiate(CharacterPrefab);
GameObjectHelper.UpdateSprite(characterObject, "CharacterSprite", gameDataObject.assetLibrary.getSprite(character.characterSpritesheetName, character.characterSpriteIndex));
if (character.type == CharacterType.Player)
{
GameObjectHelper.UpdateSpriteColor(characterObject, "HighlightSprite", Color.green);
if (battleGame.ActiveCharacter.Equals(character))
{
GameObjectHelper.UpdateSpriteColor(characterObject, "HighlightSprite", Color.yellow);
}
}
else
{
GameObjectHelper.UpdateSpriteColor(characterObject, "HighlightSprite", Color.red);
}
var characterPos = getWorldPosFromTilePoint(new Point(character.x, -character.y));
characterObject.transform.position = characterPos;
return characterObject;
}
public bool IsCloseTo(GameCharacter other)
{
return false;
}
public bool Move(GameCharacter character, IntVec position, bool absolute = false)
{
bool moveWasMade = false;
if (absolute && !isSolid( position ) )
moveWasMade = CharacterEntities.SetPosition(character, position);
else
if ( !absolute && !isSolid( CharacterEntities.FindPosition(character) + position ) )
moveWasMade = CharacterEntities.AddPosition(character, position);
return moveWasMade;
}
private GameObject updateInitPortrait(GameObject charPortrait, GameCharacter character)
{
var panelImg = charPortrait.GetComponent<Image>();
if (character.type == CharacterType.Player)
{
panelImg.color = Color.green;
}
else
{
panelImg.color = Color.red;
}
if (character == battleGame.ActiveCharacter)
{
panelImg.color = Color.yellow;
}
UIHelper.UpdateSpriteComponent(charPortrait, "PortraitImage", gameDataObject.assetLibrary.getSprite(character.portraitSpritesheetName, character.portraitSpriteIndex));
UIHelper.UpdateSliderValue(charPortrait, "HPSlider", (float)character.hp / (float)character.totalHP);
UIHelper.AddClickToGameObject(charPortrait, MoveCameraToCharacter, EventTriggerType.PointerClick, character);
return charPortrait;
}
