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; }