private void OnClick_BuyAll(object sender, RoutedEventArgs e)
{
GroupedInventoryItem groupedInventoryItem =
((FrameworkElement)sender).DataContext as GroupedInventoryItem;
if (groupedInventoryItem != null)
{
if (Session.CurrentPlayer.Gold >= (groupedInventoryItem.Item.Price * groupedInventoryItem.Quantity))
{
Session.CurrentPlayer.SpendGold(groupedInventoryItem.Item.Price * groupedInventoryItem.Quantity);
int quantita = groupedInventoryItem.Quantity;
while (1 < groupedInventoryItem.Quantity)
{
Session.CurrentTrader.RemoveItemFromInventory(groupedInventoryItem.Item);
}
Session.CurrentTrader.RemoveItemFromInventory(groupedInventoryItem.Item);
if (groupedInventoryItem.Item.Category == GameItem.ItemCategory.Spell)
{
Session.CurrentPlayer.AddItemToInventory(SpellFactory.CreateSpell(groupedInventoryItem.Item.ItemTypeID));
}
else
{
for (int i = 0; i < quantita; i++)
{
Session.CurrentPlayer.AddItemToInventory(groupedInventoryItem.Item);
}
}
}
else
{
MessageBox.Show("Nemáš dost zlatých.");
}
}
}
//=====================================================================
/// <summary>
/// Private constructor
/// </summary>
/// <param name="culture">The language to use for the dictionary</param>
/// <param name="spellFactory">The spell factory to use when checking words</param>
/// <param name="dictionaryFile">The dictionary file</param>
/// <param name="userWordsFile">The user dictionary words file</param>
/// <param name="serviceProvider">A service provider for interacting with the solution/project</param>
private GlobalDictionary(CultureInfo culture, SpellFactory spellFactory, string dictionaryFile,
string userWordsFile, IServiceProvider serviceProvider)
{
this.culture = culture;
this.spellFactory = spellFactory;
this.dictionaryFile = dictionaryFile;
this.serviceProvider = serviceProvider;
if (String.IsNullOrWhiteSpace(dictionaryFile))
{
throw new ArgumentException("Dictionary filename cannot be null or empty", "dictionaryFile");
}
registeredServices = new List <WeakReference>();
dictionaryWords = new HashSet <string>(StringComparer.InvariantCultureIgnoreCase);
if (String.IsNullOrWhiteSpace(userWordsFile))
{
dictionaryWordsFile = Path.Combine(SpellingConfigurationFile.GlobalConfigurationFilePath,
culture.Name + "_User.dic");
}
else
{
dictionaryWordsFile = userWordsFile;
}
ignoredWords = new HashSet <string>(StringComparer.InvariantCultureIgnoreCase);
recognizedWords = new HashSet <string>(StringComparer.InvariantCultureIgnoreCase);
this.LoadUserDictionaryFile();
}
public void SetUp()
{
_input = new MockInput();
_output = new MockOutput();
_menuFactory = new MenuFactory();
_manager = new MenuManager(_input, _output, _menuFactory);
_logger = new EventLogger();
_playerOne = (TestHumanFighter)TestFighterFactory.GetFighter(TestFighterType.TestHuman, 1, "swordsman");
Spell fireSpell = SpellFactory.GetSpell(MagicType.Fire, 1);
_playerOne.AddSpell(fireSpell);
_playerOne.SetMana(fireSpell.Cost);
_playerTwo = (TestHumanFighter)TestFighterFactory.GetFighter(TestFighterType.TestHuman, 1, "mage");
_playerThree = (TestHumanFighter)TestFighterFactory.GetFighter(TestFighterType.TestHuman, 1, "alchemist");
_playerTeam = new Team(_manager, _playerOne, _playerTwo, _playerThree);
_enemyTeam = new Team(_manager, new List <IFighter>
{
FighterFactory.GetFighter(FighterType.Goblin, 1),
FighterFactory.GetFighter(FighterType.Goblin, 1),
FighterFactory.GetFighter(FighterType.Goblin, 1)
});
_manager.InitializeForBattle(_playerTeam, _enemyTeam);
}
bool _gameOver = false; //Pauses the game on death
public PlayScene(Game game)
{
_game = game;
//Give systems a static PlayScene reference
GameObject.InitSceneReference(this);
Ability.InitSceneReference(this);
Effect.InitSceneReference(this);
Item.InitItemIdentifications();
_dungeon = new Dungeon();
_gen = new NewLevelGenerator();
_gameObjectPool = new GameObjectPool(this);
_map = new Map(this);
_turnCounter = new TurnCounter(this);
_specialEffects = new List <int>();
_currentDepth = 0;
_maxDepth = 1;
_messageQueue = new Queue <string>();
_panels = new List <Panel>();
_spellFactory = new SpellFactory();
}
public void Setup()
{
_fighter = new TestHumanFighter("Hero", 1);
_fighter.SetHealth(FighterHealth);
_fighter.SetMana(FighterMana);
_fighter.SetStrength(FighterAttack);
_fighter.SetDefense(FighterDefense);
_fighter.SetSpeed(FighterSpeed);
_fighter.SetEvade(FighterEvade);
_fighter.SetLuck(FighterLuck);
_factoryFighter = (TestHumanFighter)TestFighterFactory.GetFighter(TestFighterType.TestHuman, 1, "Ted");
_factoryFighter.AddSpell(SpellFactory.GetSpell(MagicType.Fire, 1));
_enemy = (TestEnemyFighter)TestFighterFactory.GetFighter(TestFighterType.TestEnemy, 1, "enemy");
_armoredEnemy = (TestEnemyFighter)TestFighterFactory.GetFighter(TestFighterType.TestEnemy, 1, "armored");
_superArmoredEnemy = (TestEnemyFighter)TestFighterFactory.GetFighter(TestFighterType.TestEnemy, 1, "super armored");
_input = new MockInput();
_output = new MockOutput();
_menuManager = new TestMenuManager(_input, _output);
_chanceService = new MockChanceService();
_battleManager = new TestBattleManager(_chanceService, _input, _output);
var humanTeam = new Team(_menuManager, _fighter);
_battleManager.SetHumanTeam(humanTeam);
var enemyTeam = new Team(_menuManager, _enemy);
_battleManager.SetEnemyTeam(enemyTeam);
_battleManager.SetConfig(new BattleManagerBattleConfiguration());
}
public void CastEggs_Level2Spells([Range(0, 2)] int level2EggIndex)
{
Tuple <MagicType, string> eggCombo = _level2Eggs[level2EggIndex];
string spellName = eggCombo.Item2;
MagicType spellType = eggCombo.Item1;
Spell spell = SpellFactory.GetSpell(spellName);
int damage = spell.Power + _chicken.MagicStrength;
_hero.SetMove(_doNothingMove, 4);
_hero.SetMove(_runawayMove);
_hero.SetMoveTarget(_hero);
_sidekick.SetHealth(damage + 1);
_sidekick.SetMove(_doNothingMove);
_sidekick.SetMoveTarget(_sidekick);
int typeIndex = Globals.EggMagicTypes.ToList().IndexOf(spellType);
_chanceService.PushWhichEventsOccur(typeIndex, typeIndex, (typeIndex + 1) % 3, 1); //the 3 egg types and targetting the sidekick
_battleManager.SuppressBattleIntroAndOutroMessages();
_battleManager.Battle(_humanTeam, _enemyTeam);
var outputs = _output.GetOutputs();
Assert.AreEqual(5, outputs.Length); // 1 for each egg lay, 1 for actual attack, 1 to output how much damage the fighter took
Assert.AreEqual(_castPrefix + spellName + "!\n", outputs[3].Message);
Assert.AreEqual(1, _sidekick.CurrentHealth);
}
public DancerBoss(FighterClass fighterClass, int level, IChanceService chanceService)
: base("",
level,
LevelUpManager.GetHealthByLevel <DancerBoss>(level, fighterClass),
LevelUpManager.GetManaByLevel <DancerBoss>(level, fighterClass),
LevelUpManager.GetStrengthByLevel <DancerBoss>(level, fighterClass),
LevelUpManager.GetDefenseByLevel <DancerBoss>(level, fighterClass),
LevelUpManager.GetSpeedByLevel <DancerBoss>(level, fighterClass),
LevelUpManager.GetEvadeByLevel <DancerBoss>(level, fighterClass),
LevelUpManager.GetLuckByLevel <DancerBoss>(level, fighterClass),
chanceService,
SpellFactory.GetSpellsByLevel <DancerBoss>(level, fighterClass: fighterClass)
, MoveFactory.GetMovesByLevel <DancerBoss>(level, fighterClass: fighterClass))
{
if (fighterClass == FighterClass.BossDancerKiki)
{
BaseName = "Kiki";
}
else if (fighterClass == FighterClass.BossDancerRiki)
{
BaseName = "Riki";
}
else
{
throw new ArgumentOutOfRangeException(nameof(fighterClass), "DancerBoss class can only be initialized with Kiki or Riki fighter class!");
}
}
void TryCastPush(JToken parsed)
{
if (Entity.SpellCooldowns.ContainsKey(SpellFactory.PUSH_INDEX))
{
return;
}
var currWorld = Program.State.World;
var currEnt = currWorld.GetByID(Entity.ID);
if (!ManaCheck(currEnt, SpellFactory.PUSH_MANA))
{
return;
}
Entity targetEnt;
if (!TryGetTargetFromPosition(parsed[2], currWorld, out targetEnt))
{
return;
}
if (targetEnt.Team == currEnt.Team)
{
return;
}
if (!SpellFactory.CheckRange(currEnt, targetEnt, SpellFactory.PUSH_RANGE))
{
return;
}
var mut = new EntityCastSpellMutation(Entity.ID, SpellFactory.CreatePush(targetEnt.ID));
Program.QueuedMutations[mut.Time].Enqueue(mut);
_CastingSpell = true;
UpdateVelocity();
}
void TryCastHealingStrike(JToken parsed)
{
if (Entity.SpellCooldowns.ContainsKey(SpellFactory.HEALING_STRIKE_INDEX))
{
return;
}
var currWorld = Program.State.World;
var currEnt = currWorld.GetByID(Entity.ID);
if (!ManaCheck(currEnt, SpellFactory.HEALING_STRIKE_MANA))
{
return;
}
Vector2 target = new Vector2((float)parsed[2]["x"], (float)parsed[2]["y"]);
var mind = Polygon2.MinDistance(currEnt.Attributes.Bounds, currEnt.Location, target);
if (mind != null && mind.Item2 > SpellFactory.HEALING_STRIKE_RANGE)
{
return;
}
var mut = new EntityCastSpellMutation(Entity.ID, SpellFactory.CreateHealingStrike(target));
Program.QueuedMutations[mut.Time].Enqueue(mut);
_CastingSpell = true;
UpdateVelocity();
}
public void CastEggs_ChaosEgg()
{
Spell spell = SpellFactory.GetSpell("chaos egg");
int damage = spell.Power + _chicken.MagicStrength;
_hero.SetHealth(damage + 1);
_hero.SetMove(_doNothingMove, 4);
_hero.SetMove(_runawayMove);
_hero.SetMoveTarget(_hero);
_sidekick.SetHealth(damage + 1);
_sidekick.SetMove(_doNothingMove);
_sidekick.SetMoveTarget(_sidekick);
_chanceService.PushWhichEventsOccur(0, 1, 2);
BattleManagerBattleConfiguration config = new BattleManagerBattleConfiguration
{
ShowIntroAndOutroMessages = false
};
_battleManager.Battle(_humanTeam, _enemyTeam, config: config);
var outputs = _output.GetOutputs();
Assert.AreEqual(7, outputs.Length); // 1 for each egg lay, 1 for actual attack, 3 to output how much damage each fighter took
Assert.AreEqual($"{_castPrefix}chaos egg!\n", outputs[3].Message);
Assert.AreEqual(1, _hero.CurrentHealth);
Assert.AreEqual(1, _sidekick.CurrentHealth);
Assert.AreEqual(_chicken.MaxHealth - damage, _chicken.CurrentHealth);
}
private void InitPropertyDescription()
{
if (SpellID > 0)
{
CharacterSpell characterSpell = SpellFactory.CreateCharacterSpell((ECharacterSpell)SpellID);
if (characterSpell != null)
{
GameConfig game = ConfigManager.Instance.Game;
Single p_magicFactor;
if (ScrollTier == 1)
{
p_magicFactor = game.ScrollNoviceMagicFactor;
}
else if (ScrollTier == 2)
{
p_magicFactor = game.ScrollExpertMagicFactor;
}
else if (ScrollTier == 3)
{
p_magicFactor = game.ScrollMasterMagicFactor;
}
else
{
p_magicFactor = game.ScrollGrandmasterMagicFactor;
}
m_properties["SCROLL_EFFECT"] = characterSpell.NameKey;
m_properties["SCROLL_SPELL_DESCRIPTION"] = characterSpell.GetDescription(p_magicFactor);
}
}
}
public HumanFighter(string name, int level, List <Spell> spells = null, List <SpecialMove> specialMoves = null)
: base(name
, level
, LevelUpManager.GetHealthByLevel(level)
, LevelUpManager.GetManaByLevel(level)
, LevelUpManager.GetStrengthByLevel(level)
, LevelUpManager.GetDefenseByLevel(level)
, LevelUpManager.GetSpeedByLevel(level)
, LevelUpManager.GetEvadeByLevel(level)
, LevelUpManager.GetLuckByLevel(level)
, SpellFactory.GetSpellsByLevel <HumanFighter>(level)
, MoveFactory.GetMovesByLevel <HumanFighter>(level)
)
{
if (spells != null)
{
Spells.AddRange(spells);
}
if (specialMoves != null)
{
SpecialMoves.AddRange(specialMoves);
}
_extraSpecialMoves = new List <BattleMove>();
CurrentExp = LevelUpManager.GetExpForLevel(level);
_expToNextLevel = LevelUpManager.GetExpForLevel(level + 1);
}
public SpellWrapper(UnitySpellData spellData)
{
this.spellData = spellData;
spellsDictionary = new Dictionary <int, ISpellController>();
spellFactory = new SpellFactory(spellData);
localSpells = new List <ISpellController>();
onlineSpells = new List <ISpellController>();
}
// Use this for initialization
void Start()
{
curFactory = new HealFactory();
spellDamage = -1;
spellQueueBox.color = new Color(1, 1, 0);
spellQueueText.text = "";
personsRemainingText.text = personsRemaining.ToString();
}
public void Execute(LivingEntity actor, LivingEntity target)
{
string actorName = (actor is Player) ? "Ty" : $" {actor.Name.ToLower()}";
string targetName = (target is Player) ? "se" : $" {target.Name.ToLower()}";
ReportResult($"{actorName} si {targetName} naučil nové kouzlo.");
target.AddItemToInventory(SpellFactory.CreateSpell(_spellID));
}
public BattleObjectFactory(Vector <BattleObject> map, Engine.BattleEngine battleEngine)
{
_map = map;
_buildingFactory = new BuildingFactory(this, battleEngine);
_unitFactory = new UnitFactory(this, battleEngine);
_bulletFactory = new BulletFactory(this, battleEngine);
_spellFactory = new SpellFactory(this, battleEngine);
_damageFactory = new DamageFactory(this, battleEngine);
}
public void SetUp()
{
_menuInput = new MockInput();
_menuOutput = new MockOutput();
_menuManager = new TestMenuManager(_menuInput, _menuOutput);
_player = (TestHumanFighter)TestFighterFactory.GetFighter(TestFighterType.TestHuman, 1);
Spell fireball = SpellFactory.GetSpell(MagicType.Fire, 1);
Spell earthSpell = SpellFactory.GetSpell(MagicType.Earth, 1);
_player.AddSpell(fireball);
_player.AddSpell(earthSpell);
_player.SetMana(fireball.Cost);
_playerTeam = new Team(_menuManager, _player);
_enemyTeam = new Team(_menuManager, (EnemyFighter)FighterFactory.GetFighter(FighterType.Goblin, 1));
_menu = (Menu)Globals.MenuFactory.GetMenu(MenuType.ChooseAttackTypeMenu, _menuInput, _menuOutput);
_menu.Build(_player, _playerTeam, _enemyTeam, null);
_fullSpellMenuPrompt = new List <string>
{
$"Which spell would you like to cast?\n{_player.DisplayName} currently has {_player.CurrentMana} / {_player.MaxMana} Mana\n",
};
var spellMenu = (SpellSelectionMenu)Globals.MenuFactory.GetMenu(MenuType.ChooseSpellMenu);
spellMenu.Build(_player, _playerTeam, _enemyTeam, null);
var spellMenuActions = spellMenu.MenuActions;
for (var i = 0; i < spellMenuActions.Count; ++i)
{
_fullSpellMenuPrompt.Add((i + 1) + ". " + spellMenuActions[i].DisplayText + "\n");
}
_fullSpellMenuPrompt.Add(StatusPrompt);
_fullSpellMenuPrompt.Add(HelpPrompt);
_fullMenuPrompt = new List <string>
{
"How would you like to fight?\n",
"1. attack\n",
"2. magic\n",
StatusPrompt,
HelpPrompt
};
_fullTargetMenuPrompt = new List <string>
{
"Who will you target for this action?\n",
"1. " + _enemyTeam.Fighters[0].DisplayName + "\n",
StatusPrompt,
BackPrompt,
HelpPrompt
};
}
public CastMonsterSpellInteraction(SpawnCommand p_command, Int32 p_parentID, Int32 p_commandIndex) : base(p_command, p_parentID, p_commandIndex)
{
m_parent = Grid.FindInteractiveObject(m_parentID);
m_interactiveObject = Grid.FindInteractiveObject(m_targetSpawnID);
CreateDummyMonster();
m_spell = SpellFactory.CreateMonsterSpell((EMonsterSpell)m_spellID, String.Empty, 1);
m_spell.MonsterMagicPower = m_magicFactor;
m_dummyMonsterHandler.CastedSpell = m_spell;
}
public override WordCorrectness IsCorrect(string word)
{
// Check the spelling.
SpellFactory checker = Plugin.SpellEngine["en_US"];
bool isCorrect = checker.Spell(word);
return(isCorrect
? WordCorrectness.Correct
: WordCorrectness.Incorrect);
}
public void TestGetSpellMethod_Level2([Values(MagicType.Fire, MagicType.Water, MagicType.Wind, MagicType.Earth)] MagicType type)
{
var ret = SpellFactory.GetSpell(type, 2);
var expected = _level2SpellCombos.First(sc => sc.Item1 == type);
Assert.AreEqual(5, ret.Cost);
Assert.AreEqual(type, ret.ElementalType);
Assert.AreEqual(3, ret.Power);
Assert.AreEqual(expected.Item2, ret.Description);
}
//=====================================================================
/// <inheritdoc />
public void Dispose()
{
if (spellFactory != null)
{
spellFactory.Dispose();
spellFactory = null;
registeredServices.Clear();
}
}
//=====================================================================
/// <summary>
/// Private constructor
/// </summary>
/// <param name="culture">The language to use for the dictionary</param>
/// <param name="spellFactory">The spell factory to use when checking words</param>
private GlobalDictionary(CultureInfo culture, SpellFactory spellFactory)
{
this.Language = culture;
this.spellFactory = spellFactory;
ignoredWords = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
ignoredWordsFile = Path.Combine(SpellCheckerConfiguration.ConfigurationFilePath,
culture.Name + "_Ignored.dic");
this.LoadIgnoredWordsFile();
}
private void InitializeSpellData()
{
JArray data = JArray.Parse(spellJson.text);
foreach (var spell in data)
{
var spellResult = SpellFactory.GetSpell(spell);
spellData.Add(spellResult.name, spellResult);
}
}
public void LoadResources()
{
SpellFactory.LoadSpells();
AfflictionFactory.LoadAfflictions();
RaceFactory.LoadTemplates();
CharacterFactory.LoadCharacters();
ArcheTypeFactory.LoadArcheTypes();
SkillsetFactory.LoadSkillsets();
SignatureSpellFactory.LoadSignatureSpells();
NormalAttackFactory.LoadNormalAttacks();
Party.Reset();
}
public void ShowCurrentPreviewSpell(EnumElement?currentSelectedElement)
{
if (currentSelectedElement == null)
{
PreviewSpells.ForEach(p => p.Disable());
return;
}
var type = SpellFactory.GetPreviewSpellType(Element, currentSelectedElement.Value);
PreviewSpells.FirstOrDefault(p => p.Type == type).Enable();
}
protected override void DoExecute()
{
CharacterSpell characterSpell = SpellFactory.CreateCharacterSpell((ECharacterSpell)m_spellID);
if (characterSpell != null)
{
characterSpell.CastSpellByInteractiveObject(m_magicFactor);
FinishExecution();
return;
}
throw new Exception("Invalid spell ID " + m_spellID);
}
public override void cast(Champion champOwner)
{
SpellData spell = new SpellFactory().getSpell("abiScry");
spell.champTag = champOwner.tag;
GameObject.Find("Canvas").transform.Find("ScryCard").gameObject.GetComponent <GuiCardData>().cData = champOwner.deck[0];
GameObject.Find("Canvas").transform.Find("ScryCard").gameObject.GetComponent <GuiCardData> ().spell = true;
GameObject.Find("Canvas").transform.Find("ScryCard").gameObject.SetActive(true);
GameObject.Find("SpellManager").GetComponent <SpellManager> ().spell = spell;
champOwner.photonView.RPC("setBusy", PhotonTargets.MasterClient, true);
}
public void Setup()
{
_fighter = (TestHumanFighter)TestFighterFactory.GetFighter(TestFighterType.TestHuman, 1, "Ted");
_enemy = (TestEnemyFighter)TestFighterFactory.GetFighter(TestFighterType.TestEnemy, 1, "enemy");
_logger = new EventLogger();
_logger.SubscribeAll(_fighter);
_logger.SubscribeAll(_enemy);
_fireballSpell = SpellFactory.GetSpell(MagicType.Fire, 1);
_fighter.AddSpell(_fireballSpell);
_fighter.SetMana(_fireballSpell.Cost);
_logger.ClearLogs();
}
// Update is called once per frame
void Update()
{
if (player.Minion && Input.GetKeyDown(KeyCode.Return))
{
var inputValue = ic.GetInputValue().Split(' ');
Debug.Log(string.Format("Getted input value {0}", inputValue));
Spell spell = SpellFactory.GetSpell(inputValue[0].ToLower());
if (inputValue.Length >= 2)
{
spell?.Cast(player.Minion, inputValue[1].ToUpper());
}
}
}
public Ogre(int level, IChanceService chanceService)
: base("Ogre",
level,
LevelUpManager.GetHealthByLevel <Ogre>(level),
LevelUpManager.GetManaByLevel <Ogre>(level),
LevelUpManager.GetStrengthByLevel <Ogre>(level),
LevelUpManager.GetDefenseByLevel <Ogre>(level),
LevelUpManager.GetSpeedByLevel <Ogre>(level),
LevelUpManager.GetEvadeByLevel <Ogre>(level),
LevelUpManager.GetLuckByLevel <Ogre>(level),
chanceService,
SpellFactory.GetSpellsByLevel <Ogre>(level)
, MoveFactory.GetMovesByLevel <Ogre>(level))
{
}
