public StoryManager(MenuActionService actionService, Hero hero, EnemyService enemyService)
{
_actionService = actionService;
_hero = hero;
enemies = new List <Enemy>();
_enemyService = enemyService;
}
public IHttpActionResult GetAll()
{
EnemyService enemyService = CreateEnemyService();
var enemies = enemyService.GetEnemies();
return(Ok(enemies));
}
public EnemyManagerService(
GameObject enemyObjectPrefab,
GameObject enemyContainer,
PlayerService playerService,
EnemyService enemyService,
EnemyTurnService enemyTurnService,
StatusService statusService,
DeckService deckService,
EnemyTypes enemyTypes,
CardUiManager cardUiManager,
CardGeneratorService cardGeneratorService,
SceneUiManager sceneUiManager,
UpgradeUiManager upgradeUiManager,
UpgradeService upgradeService
)
{
this.enemyObjectPrefab = enemyObjectPrefab;
this.enemyContainer = enemyContainer;
this.enemyService = enemyService;
this.enemyTurnService = enemyTurnService;
this.statusService = statusService;
this.playerService = playerService;
this.deckService = deckService;
this.enemyTypes = enemyTypes;
this.cardUiManager = cardUiManager;
this.cardGeneratorService = cardGeneratorService;
this.sceneUiManager = sceneUiManager;
this.upgradeUiManager = upgradeUiManager;
this.upgradeService = upgradeService;
}
private EnemyService CreateEnemyService()
{
var userId = Guid.Parse(User.Identity.GetUserId());
var enemyService = new EnemyService(userId);
return(enemyService);
}
//GET: Enemy/Detail
public ActionResult Details(int id)
{
var service = new EnemyService();
var model = service.GetEnemyByID(id);
return(View(model));
}
public IHttpActionResult Get(int id)
{
EnemyService enemyService = CreateEnemyService();
var enemy = enemyService.GetEnemyById(id);
return(Ok(enemy));
}
public ActionResult DeleteEnemy(int id)
{
var service = new EnemyService();
service.DeleteEnemy(id);
return(RedirectToAction("Index"));
}
// GET: Enemy
public ActionResult Index()
{
var userId = Guid.Parse(User.Identity.GetUserId());
var service = new EnemyService(userId);
var model = service.GetEnemies();
return(View(model));
}
//GET: Enemy/Create
public ActionResult Create()
{
var service = new EnemyService();
ViewBag.LocationID = new SelectList(ctx.Locations.ToList(), "ID", "Name");
return(View());
}
public void CantGetEnemiesByIncorrectDiffLvl()
{
var enemyService = new EnemyService();
var enemiesByDiffLvl = enemyService.GetEnemiesByDiffLvl(4);
enemiesByDiffLvl.Should().BeEmpty();
enemiesByDiffLvl.Should().BeOfType(typeof(List <Enemy>));
}
public void CantGetEnemiesByIncorrectCategory()
{
var enemyService = new EnemyService();
var enemiesByCategory = enemyService.FindEnemiesByCategory(enemyService.Objects, "Master");
enemiesByCategory.Should().BeEmpty();
enemiesByCategory.Should().BeOfType(typeof(List <Enemy>));
}
public void CanGetEnemiesByCategory()
{
var enemyService = new EnemyService();
var enemiesByCategory = enemyService.FindEnemiesByCategory(enemyService.Objects, "Archer");
enemiesByCategory.Should().NotBeNull();
enemiesByCategory.Should().NotBeEmpty();
enemiesByCategory.Should().BeOfType(typeof(List <Enemy>));
}
public void CanGetEnemiesByDiffLvl()
{
var enemyService = new EnemyService();
var enemiesByDiffLvl = enemyService.GetEnemiesByDiffLvl(1);
enemiesByDiffLvl.Should().NotBeNull();
enemiesByDiffLvl.Should().NotBeEmpty();
enemiesByDiffLvl.Should().BeOfType(typeof(List <Enemy>));
}
private void Start()
{
enemyService = EnemyService.Instance;
if (spawnEnumerator != null)
{
StopCoroutine(spawnEnumerator);
}
spawnEnumerator = StartCoroutine(spawnEnemy(5));
}
public void EnemyService_PacmanNull_ArgumentNullException()
{
IPacman pacman = null;
try
{
EnemyService = new EnemyService(Count, Maze.Object, pacman, TimeService);
}
catch (ArgumentNullException ex)
{
Assert.AreEqual("Pacman", ex.ParamName);
}
}
public CardService(
EnemyManagerService enemyManagerService,
PlayerService playerService,
AudioState audioState,
DeckService deckService,
EnemyService enemyService)
{
this.enemyManagerService = enemyManagerService;
this.playerService = playerService;
this.audioState = audioState;
this.deckService = deckService;
this.enemyService = enemyService;
}
public void EnemyService_MazeNull_ArgumentNullException()
{
IMaze maze = null;
try
{
EnemyService = new EnemyService(Count, maze, Pacman.Object, TimeService);
}
catch (ArgumentNullException ex)
{
Assert.AreEqual("Maze", ex.ParamName);
}
}
public void EnemyService_TimeServiceNull_ArgumentNullException()
{
TimeService timeService = null;
try
{
EnemyService = new EnemyService(Count, Maze.Object, Pacman.Object, timeService);
}
catch (ArgumentNullException ex)
{
Assert.AreEqual("TimeService", ex.ParamName);
}
}
public void EnemyServiceCtr_CountEnemiris0_Exeption()
{
try
{
EnemyService = new EnemyService(0, Maze.Object, Pacman.Object, TimeService);
}catch (ArgumentException ex)
{
Assert.AreEqual("Count Enemies can't be less 1", ex.Message);
}
catch (Exception e)
{
Assert.Fail(
string.Format("Unexpected exception of type {0} caught: {1}",
e.GetType(), e.Message));
}
}
public void CanResetEnemies()
{
var enemyService = new EnemyService();
var enemyServiceActual = new EnemyService();
var archers = enemyService.FindEnemiesByCategory(enemyService.Objects, "Archer");
var archer = archers.FirstOrDefault(en => en.Attack == 7);
archer.SetHealth(6);
enemyService.ResetEnemies();
archers.Should().NotBeNull();
archers.Should().NotBeEmpty();
archers.Should().BeOfType(typeof(List <Enemy>));
archers.Should().BeEquivalentTo(enemyServiceActual.FindEnemiesByCategory(enemyServiceActual.Objects, "Archer"));
}
public void ChangeSpeed()
{
if (currentSpeed == InGameService.DEFAULT_SPEED)
{
currentSpeed = InGameService.DOUBLE_SPEED;
EnemyService.SetDoubleSpeed();
}
else
{
currentSpeed = InGameService.DEFAULT_SPEED;
EnemyService.SetDefaultSpeed();
}
ChangeText();
ChangeTimeScale();
}
public ActionResult Create(EnemyCreate model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var service = new EnemyService();
if (service.CreateEnemy(model))
{
return(RedirectToAction("Index"));
}
ModelState.AddModelError("", "Enemy could not be created");
return(View(model));
}
// GET: Enemy
//public ActionResult Index()
//{
// var service = new EnemyService();
// var model = service.GetEnemies();
// return View(model);
//}
public ActionResult Index(string sortOrder)
{
ViewBag.NameSortParm = String.IsNullOrEmpty(sortOrder) ? "name_desc" : "";
var service = new EnemyService();
var enemies = from enemy in service.GetEnemies() select enemy;
switch (sortOrder)
{
case "name_desc":
enemies = enemies.OrderBy(enemy => enemy.Name);
break;
default:
enemies.OrderBy(e => e.EnemyID);
break;
}
return(View(enemies.ToList()));
}
// Use this for initialization
void Awake()
{
player = GameObject.FindGameObjectWithTag("Player");
playerModel = player.gameObject.GetComponent <PlayerModel>();
playerController = player.GetComponent <PlayerController>();
enemy = GameObject.FindGameObjectWithTag("Enemy");
enemyService = enemy.gameObject.GetComponent <EnemyService> ();
enemyModel = enemy.gameObject.GetComponent <EnemyModel> ();
print(enemyModel.name);
target = player.transform;
range = 10f;
speed = 2f;
AttackTime = 2f;
coolDown = 2f;
magicCooldown = 0f;
}
void updateEnemies()
{
// get updated encounter data to move
encounters = EnemyService.getUpdatedEncounterData(gameId);
foreach (Encounter encounter in encounters)
{
GameObject encounterObj;
if (encounterObjects.TryGetValue(encounter.encounterId, out encounterObj))
{
encounterObj.GetComponent <EnemyController>().encounter = encounter;
}
else
{
GameObject enemySpawn = PhotonNetwork.Instantiate(enemyPrefab.name, new Vector3(0, 0, 0), Quaternion.identity, 0);
enemySpawn.GetComponent <EnemyController>().encounter = encounter;
encounterObjects.Add(encounter.encounterId, enemySpawn);
}
}
}
//GET: Enemy/Edit
public ActionResult Edit(int id)
{
var service = new EnemyService();
var detail = service.GetEnemyByID(id);
ViewBag.LocationID = new SelectList(ctx.Locations.ToList(), "ID", "Name");
var model = new EnemyEdit
{
EnemyID = detail.EnemyID,
Name = detail.Name,
Description = detail.Description,
Health = detail.Health,
LocationID = detail.LocationID,
Location = detail.Location
};
return(View(model));
}
public ActionResult Edit(int id, EnemyEdit model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
if (model.EnemyID != id)
{
ModelState.AddModelError("", "Wrong ID");
return(View(model));
}
var service = new EnemyService();
if (service.UpdateEnemy(model))
{
return(RedirectToAction("Index"));
}
ModelState.AddModelError("", "Error");
return(View(model));
}
void Start()
{
//Get references to GameObjects from scene
takeObjectsFromScene();
//prefabs. no dependencies.
GameObject upgradePrefab = Resources.Load(FilePathUtils.prefabPath + "upgradeObject") as GameObject;
GameObject cardPrefab = Resources.Load(FilePathUtils.prefabPath + "cardObject") as GameObject;
GameObject campContractPrefab = Resources.Load(FilePathUtils.prefabPath + "campContractObject") as GameObject;
GameObject healthBarPrefab = Resources.Load(FilePathUtils.prefabPath + "healthBarObject") as GameObject;
GameObject enemyPrefab = Resources.Load(FilePathUtils.prefabPath + "enemyObject") as GameObject;
GameObject eventButtonPrefab = Resources.Load(FilePathUtils.prefabPath + "eventButtonObject") as GameObject;
//Data classes. no dependencies
GameData gameData = new GameData();
GameData.setInstance(gameData);
//Ui manager, only dependencies are GameObjects
CardUiManager cardUiManager = new CardUiManager(
cardPrefab,
playerHandObject,
cardListGrid,
cardListScene,
cardSelectUi
);
SceneUiManager sceneUiManager = new SceneUiManager(
startScene,
gameOverScene,
victoryScene,
cardListScene,
fightSceneObject,
campScene,
eventScene
);
UpgradeUiManager upgradeUiManager = new UpgradeUiManager(
upgradeSelect,
upgradePrefab,
upgradeList
);
CampContractUiManager campContractUiManager = new CampContractUiManager(
campContractPrefab,
campContracts
);
//Types
StatusTypes statusTypes = new StatusTypes();
EnemyTypes enemyTypes = new EnemyTypes(enemyPrefab);
CardTypes cardTypes = new CardTypes();
cardTypes.initialize(statusTypes);
//GameObjects
PlayerGameObject playerGameObject = playerObject.GetComponent <PlayerGameObject>();
playerGameObject.initalize(playerObject);
gameData.playerGameObject = playerGameObject;
FightSceneGameObject fightSceneGameObject = fightSceneObject.GetComponent <FightSceneGameObject>();
fightSceneGameObject.initalize(fightSceneObject);
//Services
UpgradeService upgradeService = new UpgradeService();
EnemyTurnService enemyTurnService = new EnemyTurnService();
StatusService statusService = new StatusService(statusTypes);
EnemyService enemyService = new EnemyService(enemyTurnService, statusService);
CardGeneratorService cardGeneratorService = new CardGeneratorService(cardTypes);
PlayerService playerService = new PlayerService(sceneUiManager, statusService, playerGameObject);
DeckService deckService = new DeckService(cardUiManager, playerService);
CampContractService campContractService = new CampContractService(campContractUiManager);
EnemyManagerService enemyManagerService = new EnemyManagerService(
enemyPrefab,
enemyContainer,
playerService,
enemyService,
enemyTurnService,
statusService,
deckService,
enemyTypes,
cardUiManager,
cardGeneratorService,
sceneUiManager,
upgradeUiManager,
upgradeService
);
CardService cardService = new CardService(enemyManagerService, playerService, new AudioState(), deckService, enemyService);
CampService campService = new CampService(campScene, campSelectionScene, campContractService, cardTypes);
CardActionsService cardActionsService = new CardActionsService(deckService, playerService, cardService);
EnemyManagerService.setInstance(enemyManagerService);
UpgradeTypes upgradeTypes = new UpgradeTypes(playerService);
EventManagerService eventManagerService = new EventManagerService(
eventBoard,
eventBoardButtons,
eventButtonPrefab,
campTitleText,
campText
);
FightManagerService fightManagerService = new FightManagerService(
sceneUiManager,
cardUiManager,
playerService,
upgradeUiManager,
deckService,
campService,
upgradeService,
enemyManagerService,
eventManagerService
);
eventManagerService.setFightService(fightManagerService);
cardUiManager.initialize(cardActionsService);
upgradeUiManager.initialize(upgradeService);
deckService.initialize(enemyManagerService);
//Initialize game data class
gameData.deckService = deckService;
gameData.playerService = playerService;
gameData.upgradeService = upgradeService;
gameData.enemyTypes = enemyTypes;
//init scene buttons + add click events
startNewRunButton.onClick.AddListener(() => fightManagerService.startNewRun(upgradeTypes, cardTypes));
runItBackButton.onClick.AddListener(() => fightManagerService.startNewRun(upgradeTypes, cardTypes));
nextFightButton.onClick.AddListener(fightManagerService.startFight);
closeCardListButton.onClick.AddListener(cardUiManager.hideCardPile);
closeCampListButton.onClick.AddListener(() => campService.hideCampFightList());
leaveCampButton.onClick.AddListener(() => fightManagerService.confirmCampEvents());
DeckData deckData = gameData.deckData;
addEventTrigger(showDeckObject).callback.AddListener((data) => cardUiManager.showCardPile(deckData.deckCards));
addEventTrigger(showDiscardObject).callback.AddListener((data) => cardUiManager.showCardPile(deckData.discardCards));
addEventTrigger(showTrashObject).callback.AddListener((data) => cardUiManager.showCardPile(deckData.trash));
addEventTrigger(endTurnObject).callback.AddListener((data) => fightManagerService.endTurn());
addEventTrigger(extraDrawObject).callback.AddListener((data) => deckService.extraDraw());
addEventTrigger(wellGameObject).callback.AddListener((data) => campService.showCampFightList());
addEventTrigger(shopGameObject).callback.AddListener((data) => campService.showCampFightList());
//hide well/shop buttons
wellGameObject.SetActive(false);
shopGameObject.SetActive(false);
}
public static CharacterManager FightMenu(MenuActionService actionService, CharacterManager characterManager, ItemManager itemManager)
{
bool isMonsterLive = true;
bool isHeroLive = true;
bool isEscaped = false;
IEnemyService enemyService = new EnemyService();
enemyService.GenerateNewEnemy(characterManager.GetHeroLevel());
int[] hiddenHeroStats = characterManager.GetHiddenStats();
int[] hiddenEnemyStats = enemyService.GetHiddenStats();
do
{
Console.Clear();
Console.WriteLine("Your hero:");
characterManager.ShowHeroInfoInFight();
Console.WriteLine();
enemyService.ShowMonsterInfo();
List <MenuAction> dungeonMenu = actionService.GetMenuActionsByMenuName("Fight");
int selectedOption;
Console.WriteLine();
for (int i = 0; i < dungeonMenu.Count; i++)
{
Console.WriteLine($"{dungeonMenu[i].Id}. {dungeonMenu[i].Name}");
}
var readedKey = Console.ReadKey();
Int32.TryParse(readedKey.KeyChar.ToString(), out selectedOption);
switch (selectedOption)
{
case 1:
if (hiddenHeroStats[1] >= hiddenEnemyStats[1])
{
isMonsterLive = enemyService.DealDamage(hiddenHeroStats[0]);
Console.Read();
if (isMonsterLive)
{
isHeroLive = characterManager.GetDamage(hiddenEnemyStats[0]);
}
}
else
{
isHeroLive = characterManager.GetDamage(hiddenEnemyStats[0]);
Console.Read();
if (isHeroLive)
{
isMonsterLive = enemyService.DealDamage(hiddenHeroStats[0]);
}
}
break;
case 2:
int selectedItem;
do
{
List <Item> heroItems = characterManager.GetItems();
Console.Clear();
int counter = 1;
Console.WriteLine("Your inventory:");
foreach (var item in heroItems)
{
Console.WriteLine($"{counter}. {item.Name}");
counter++;
}
Console.WriteLine("0. Exit");
int.TryParse(Console.ReadKey().KeyChar.ToString(), out selectedItem);
Console.Clear();
if (selectedItem != 0 && selectedItem - 1 < heroItems.Count)
{
if (heroItems[selectedItem - 1].IsUsable)
{
characterManager.UseItem(selectedItem - 1);
}
else
{
Console.WriteLine("This item is not usable");
}
}
else
{
Console.WriteLine("You have chosen wrong number");
}
Console.Read();
Console.Clear();
} while (selectedItem != 0);
break;
case 3:
isEscaped = TryToEscape(hiddenHeroStats[1], hiddenEnemyStats[1]);
if (!isEscaped)
{
Console.Clear();
Console.WriteLine("Ups your enemy was too quick!");
Console.WriteLine("Click enter to continue...");
Console.Read();
isHeroLive = characterManager.GetDamage(hiddenEnemyStats[0]);
}
break;
default:
Console.WriteLine("Wrong option number");
break;
}
} while (isMonsterLive && isHeroLive && !isEscaped);
if (!isHeroLive)
{
return(null);
}
if (!isEscaped)
{
Random money = new Random();
Random experience = new Random();
Item item = itemManager.GetRandomItem(characterManager.GetHeroLevel(), characterManager.GetHeroClass());
int heroLevel = characterManager.GetHeroLevel();
int gainedMoney = money.Next(25 * heroLevel, 150 * heroLevel);
int gainedExp = experience.Next(10 * heroLevel, 200 * heroLevel);
Console.Clear();
if (!characterManager.CheckIsInventoryFull())
{
int numberOfItems = characterManager.AddItemToInventory(item);
Console.WriteLine($"You got item: {item.Name}");
Console.WriteLine($"You have {numberOfItems} items in your inventory");
}
Messages.AfterFight(gainedExp, gainedMoney);
characterManager.UpdateCharacterAfterFight(gainedMoney, gainedExp);
}
return(characterManager);
}
static void Main(string[] args)
{
MenuActionService menuActionService = new MenuActionService();
HeroService heroService = new HeroService();
HeroManager heroManager = new HeroManager(menuActionService, heroService);
EnemyService enemyService = new EnemyService();
StoryManager storyManager;
int tryHard = 0;
bool choseLvlOne = false;
bool choseLvlTwo = false;
bool choseLvlThree = false;
int lastDiffLvl = 0;
List <Hero> heroes = null;
Console.WriteLine("Welcome to RPG Game app!");
while (true)
{
int exit = 0;
Console.WriteLine("Please let me know what you want to do:");
var mainMenu = menuActionService.GetMenuActionsByMenuName("Main");
for (int i = 0; i < mainMenu.Count; i++)
{
Console.WriteLine($"{mainMenu[i].Id}. {mainMenu[i].Name}");
}
var operation = Console.ReadKey();
switch (operation.KeyChar)
{
case '1':
var newId = heroManager.AddNewHero();
break;
case '2':
heroManager.RemoveHero();
break;
case '3':
heroManager.HeroDetails();
break;
case '4':
var toShow = heroManager.ShowHeroes();
Console.WriteLine(toShow.ToStringTable(new[] { "Id", "Name", "Health", "Max Health",
"Attack", "Heal Level", "Experience", "Level", "Required Experience",
"Profession", "Typ Id" }, a => a.Id, a => a.Name, a => a.Health, a => a.MaxHealth,
a => a.Attack, a => a.HealLvl, a => a.Exp, a => a.Level, a => a.RequiredExp,
a => a.Profession, a => a.TypeId));
break;
case '5':
heroes = heroManager.GetAllHeroes();
if (heroes.Count > 0)
{
Console.WriteLine();
Console.WriteLine(heroes.ToStringTable(new[] { "Id", "Name", "Health", "Max Health",
"Attack", "Heal Level", "Experience", "Level", "Required Experience",
"Profession", "Typ Id" }, a => a.Id, a => a.Name, a => a.Health, a => a.MaxHealth,
a => a.Attack, a => a.HealLvl, a => a.Exp, a => a.Level, a => a.RequiredExp,
a => a.Profession, a => a.TypeId));
int chosenHero = -1;
Hero hero = null;
while (hero == null)
{
chosenHero = heroManager.SelectCharacter();
if (chosenHero == -1)
{
break;
}
hero = heroManager.GetHeroById(chosenHero);
}
if (chosenHero != -1)
{
Console.WriteLine($"You chose Hero {hero.Name}, level:{hero.Level}, profession:{hero.Profession}");
storyManager = new StoryManager(menuActionService, hero, enemyService);
storyManager.SetLastDiffLvl(lastDiffLvl);
storyManager.Start();
if (storyManager.DiffLvl == lastDiffLvl)
{
tryHard++;
enemyService.UpgradeEnemiesByDiffLvl(tryHard, storyManager.DiffLvl);
}
else
{
tryHard = 0;
}
lastDiffLvl = storyManager.DiffLvl;
hero.Reset();
switch (storyManager.DiffLvl)
{
case 1:
choseLvlOne = true;
break;
case 2:
choseLvlTwo = true;
break;
case 3:
choseLvlThree = true;
break;
}
if (choseLvlOne && choseLvlTwo && choseLvlThree)
{
enemyService.UpgradeEnemies(1);
choseLvlOne = false;
choseLvlTwo = false;
choseLvlThree = false;
}
}
}
else
{
Console.WriteLine("\nThere is no heroes to choose");
}
break;
case '6':
exit = 1;
if (heroes != null)
{
bool IsFileCreated = CreateXmlFileWithAllHeroes(heroes);
if (IsFileCreated)
{
Console.WriteLine("\nSaved all Heroes in file listOfAllHeroes.xml");
}
}
Console.WriteLine("Press Enter to continue");
Console.ReadLine();
break;
default:
Console.WriteLine("Action you entered does not exist");
break;
}
if (exit == 1)
{
break;
}
}
}
