public void DMSynrchronizationTest() { var DM1 = DungeonMaster.GetDebugDM(data); var DM2 = DM1.Clone() as DungeonMaster; DM2.data = DM1.data; Assert.AreEqual(DM1.map.GetGamestateHash(), DM2.map.GetGamestateHash()); Assert.AreEqual(DM1.Sides[0].ID.GetHashCode(), DM2.Sides[0].ID.GetHashCode()); Assert.AreEqual(DM1.Sides[0].Name.GetHashCode(), DM2.Sides[0].Name.GetHashCode()); Assert.AreEqual(DM1.GetGamestateHash(), DM2.GetGamestateHash()); var robby = DM1.Characters.FirstOrDefault(c => c.Name == "Robby"); var activateOutcome = DM1.Activate(robby); DM2.ApplyOutcome(activateOutcome); Assert.AreEqual(DM1.GetGamestateHash(), DM2.GetGamestateHash()); var moveOutcome = DM1.MoveCharacter(robby, Map.Direction.S); DM2.ApplyOutcome(moveOutcome); Assert.AreEqual(DM1.GetGamestateHash(), DM2.GetGamestateHash()); var attackOutcome = DM1.UseAbility("Attack", new List <string>() { "Zach" }); DM2.ApplyOutcome(attackOutcome); Assert.AreEqual(DM1.GetGamestateHash(), DM2.GetGamestateHash()); }
public void LoadEncounter() { throw new NotImplementedException(); //TODO: doesn't connect right stuff var yaml = new YamlStream(); using (StringReader r = new StringReader(levelYaml.text)) { yaml.Load(r); } var mapping = (YamlMappingNode)yaml.Documents[0].RootNode; var mapFile = (mapping[new YamlScalarNode("map_file")] as YamlScalarNode).Value; StringBuilder sb = new StringBuilder(); sb.AppendLine("Test Map"); sb.AppendLine(levelLayout.width + " " + levelLayout.height); for (int y = 1; y <= levelLayout.height; y++) { for (int x = 0; x < levelLayout.width; x++) { var color = levelLayout.GetPixel(x, levelLayout.height - y); var r = (byte)(color.r * 255); var g = (byte)(color.g * 255); var b = (byte)(color.b * 255); sb.Append(data.GetIconByColor(r, g, b).ToString()); } sb.AppendLine(); } DM = DungeonMaster.LoadEncounter(mapping, sb.ToString(), data); }
public static DungeonMaster LoadEncounter() { var data = GameData.ReadDatafilesInDirectory("GameData"); var yaml = new YamlStream(); using (StreamReader r = new StreamReader("GameData/SlimeCave.yaml")) { yaml.Load(r); } var mapping = (YamlMappingNode)yaml.Documents[0].RootNode; var mapFile = (mapping[new YamlScalarNode("map_file")] as YamlScalarNode).Value; Bitmap bitmap = new Bitmap("GameData/" + mapFile); StringBuilder sb = new StringBuilder(); sb.AppendLine("Test Map"); sb.AppendLine(bitmap.Width + " " + bitmap.Height); for (int y = 0; y < bitmap.Height; y++) { for (int x = 0; x < bitmap.Height; x++) { var color = bitmap.GetPixel(x, y); sb.Append(data.GetIconByColor(color.R, color.G, color.B).ToString()); } sb.AppendLine(); } DM = DungeonMaster.LoadEncounter(mapping, sb.ToString(), data); return(DM); }
public override Outcome Apply(DungeonMaster DM, Character user, Position posTarget, Character charTarget, Deck deck, Card cardDrawn, string optionalFeatures = null) { var outcome = charTarget.ResolveEffect(DM, user, posTarget, deck, cardDrawn, TypicalEffects); return(outcome); }
private void ProcessMessage(string message) { StringReader sr = new StringReader(message); var toDo = sr.ReadLine(); switch (toDo) { case "DM": DM = JsonConvert.DeserializeObject <DungeonMaster>(sr.ReadToEnd()); DM.SetupEvents(); DM.data = GameData.CreateFromJson(TileJson.text, CharacterJson.text, ActionJson.text); Debug.Log("Loaded level from server"); LoadCombatScene(); break; case "Take action": var outcome = JsonConvert.DeserializeObject <Outcome>(sr.ReadToEnd()); DM.ApplyOutcome(outcome); break; default: Debug.LogError("Unknown action: " + toDo); break; } }
public override Outcome Apply(DungeonMaster DM, Character user, Position posTarget, Character charTarget, Deck deck, Card cardDrawn, string optionalFeatures = null) { var outcome = new Outcome(); var tile = DM.data.GetTileByName(ReplacingTile); if (tile.Properties.Contains(Tile.TileProperties.Teleportal)) { tile.Target = user.Pos; } DM.map.MakeTile(DM, tile, posTarget, DM.data); if (tile.Properties.Contains(Tile.TileProperties.Teleportal)) { var tile2 = DM.data.GetTileByName(ReplacingTile); tile2.Target = posTarget; DM.map.MakeTile(DM, tile2, user.Pos, DM.data); } var charStanding = DM.Characters.FirstOrDefault(c => c.Pos == posTarget); if (charStanding != null) { var newTile = DM.map.GetTile(posTarget); newTile.CharacterEntered(DM, charStanding); } return(outcome); }
public override Outcome Apply(DungeonMaster DM, Character user, Position posTarget, Character charTarget, Deck deck, Card cardDrawn, string optionalFeatures = null) { var outcome = new Outcome(); deck.OnCardDrawn += DM.CardDrawn; Card card = deck.Draw(); outcome.Message.AppendLine("Drawn:" + card.ToString()); //inform user and target what card was drawn, possibly for temporary dodge or breaking shields user.CardDrawn(deck, card); if (charTarget != null) { charTarget.CardDrawn(deck, card); //TODO: apply to outcome and unify with Action class } //apply relevant effects foreach (var effect in Effects[card.TypeOfCard]) { var effectOutcome = effect.Apply(DM, user, posTarget, charTarget, deck, card, ""); outcome.Message.Append(effectOutcome.Message); } return(outcome); }
public static int ResolveSource(CardSource source, DungeonMaster DM, Character user, Position posTarget, Character charTarget) { switch (source) { case CardSource.TargetVitality: return(charTarget.Vitality.Value); case CardSource.TargetStamina: return(charTarget.Stamina.Value); case CardSource.TargetArmorCoverage: return(charTarget.ArmorCoverage); case CardSource.UserBaseAttack: return(user.WeaponAdvantage + user.Profeciency.Value); case CardSource.UserBaseDamage: return(user.Strength.Value + user.WeaponDamage); case CardSource.UserStrength: return(user.Strength.Value); default: break; } throw new NotImplementedException(); }
public void MoveRobbyAround() { var DM = DungeonMaster.GetDebugDM(data); var robby = DM.Characters[0]; var zach = DM.Characters[1]; var startingPos = robby.Pos; var outcome = DM.MoveCharacter(robby, Map.Direction.S); Assert.IsNotNull(outcome); Assert.AreEqual(startingPos, robby.Pos); //shouldn't have moved since he isn't activated yet bool eventRaised = false; DM.OnCharacterMoved += delegate(object sender, CharacterMovedEventArgs e) { Assert.AreEqual("Robby", e.Name); eventRaised = true; }; outcome = DM.Activate(robby); outcome = DM.MoveCharacter(robby, Map.Direction.S); Assert.IsTrue(eventRaised); Assert.AreNotEqual(startingPos, robby.Pos); startingPos = zach.Pos; DM.MoveCharacter(zach, Map.Direction.S); Assert.AreEqual(startingPos, zach.Pos); //shouldn't move since its not his side's turn }
public override void OnInspectorGUI() { DrawDefaultInspector(); DungeonMaster dungeon = (DungeonMaster)target; if (GUILayout.Button("Build Dungeon")) { if (!dungeon.dungeonIsBuilt) { dungeon.CreateDungeon(); dungeon.dungeonIsBuilt = true; } else { Debug.Log("Clear the scene before making another dungeon!"); } } if (GUILayout.Button("Delete Dungeon")) { if (dungeon.dungeonIsBuilt) { dungeon.ClearScene(); dungeon.dungeonIsBuilt = false; } else { Debug.Log("Nothing to clear!"); } } }
public async Task <IActionResult> PutDungeonMaster(int id, DungeonMaster dungeonMaster) { if (id != dungeonMaster.Id) { return(BadRequest()); } _context.Entry(dungeonMaster).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!DungeonMasterExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
/// <summary> /// Create a new Dungeon Master with the provided information from the API request & /// Create Request Objects between the new DM and all active players in the database. /// </summary> /// <param name="dungeonMaster">Dungeon Master information from the API request</param> /// <returns>Newly created Dungeon Master</returns> public async Task <DungeonMasterDTO> CreateDungeonMaster(DungeonMasterDTO dungeonMasterDTO) { DungeonMaster dungeonMaster = DeconstructDTO(dungeonMasterDTO); _context.Entry(dungeonMaster).State = EntityState.Added; var result = await _context.SaveChangesAsync(); dungeonMasterDTO = await BuildDTO(dungeonMaster); dungeonMasterDTO.ActiveRequests = new List <RequestDTO>(); var players = await _context.Players.Where(x => x.PartyId == 1).ToListAsync(); if (players != null) { foreach (var player in players) { RequestDTO newReq = await _request.CreateRequest(player.Id, dungeonMaster.Id); dungeonMasterDTO.ActiveRequests.Add(newReq); } } PartyDTO newParty = new PartyDTO { DungeonMasterId = dungeonMasterDTO.Id, MaxSize = dungeonMasterDTO.PartySize, Full = false }; dungeonMasterDTO.Party = await _party.CreateParty(newParty); dungeonMasterDTO.Id = dungeonMaster.Id; return(dungeonMasterDTO); }
public async Task <ActionResult <DungeonMaster> > PostDungeonMaster(DungeonMaster dungeonMaster) { _context.DungeonMasters.Add(dungeonMaster); await _context.SaveChangesAsync(); return(CreatedAtAction("GetDungeonMaster", new { id = dungeonMaster.Id }, dungeonMaster)); }
public Deck GetDeckFor(DungeonMaster DM, Character user, Position posTarget, Character charTarget) { Deck deck = new Deck(); foreach (var ingredient in DeckRecipe) { var source = ingredient.Key; int num = ResolveSource(source, DM, user, posTarget, charTarget); var card = ingredient.Value; deck.AddCards(card, num); } user.AddModifiers(deck, DM, user, charTarget, this, false); if (charTarget != null) { charTarget.AddModifiers(deck, DM, user, null, this, true); } DM.AddSituationalModifiers(deck, this, user, posTarget, charTarget); deck.Consolidate(); return(deck); }
// DO NOT rename this file's namespace or class name. // However, you ARE allowed to use your own namespaces (or no namespaces at all if you prefer) in other classes. public static void Main(string[] args) { var dungeonMaster = new DungeonMaster(); var engine = new Engine(dungeonMaster); engine.Run(); }
public void TurnPassingTest() { var DM = DungeonMaster.GetDebugDM(data); var robby = DM.Characters[0]; var zach = DM.Characters[1]; Assert.IsTrue(DM.currentSide.ID == robby.SideID); DM.Activate(robby); DM.MoveCharacter(robby, Map.Direction.S); robby.HasActed = true; DM.EndTurn(robby.SideID); Assert.IsTrue(DM.currentSide.ID == zach.SideID); Assert.AreEqual(0, DM.TurnCount); Assert.IsFalse(zach.HasBeenActivated); Assert.IsFalse(zach.HasActed); Assert.IsTrue(robby.HasActed); DM.EndTurn(zach.SideID); Assert.IsTrue(zach.HasBeenActivated); Assert.IsTrue(robby.HasActed); Assert.IsFalse(robby.HasBeenActivated); Assert.IsTrue(robby.Move.Value < robby.Move.Max); Assert.AreEqual(robby.SideID, DM.currentSide.ID); Assert.AreEqual(1, DM.TurnCount); DM.Activate(robby); Assert.IsTrue(robby.HasBeenActivated); Assert.AreEqual(robby.Move.Max, robby.Move.Value); }
public void DebugAttackArmorTest() { var DM = DungeonMaster.GetDebugDM(data); var attack = DebugData.GetDebugAttackAction(); var robby = DM.Characters[0]; var zach = DM.Characters[1]; zach.Conditions.Add(new Condition("Dodging", 3)); var outcome = new Outcome(); DM.Activate(robby); attack.ResolveAction(DM, robby, null, zach, "", outcome); //not adjacent so nothing happens Assert.IsTrue(zach.Vitality.Value == zach.Vitality.Max); zach.Pos = robby.Pos + Map.DirectionToPosition[Map.Direction.E]; Deck.SetFate(new List <string>() { "Glancing Blow" }); attack.ResolveAction(DM, robby, null, zach, "", outcome); Assert.IsTrue(zach.Vitality.Value < zach.Vitality.Max); Assert.AreEqual(zach.Vitality.Max - robby.Strength.Value - robby.WeaponDamage + zach.ArmorProtection, zach.Vitality.Value); }
public void DebugAttackDeckTest() { var DM = DungeonMaster.GetDebugDM(data); var attack = DebugData.GetDebugAttackAction(); var robby = DM.Characters[0]; var zach = DM.Characters[1]; var deck = attack.GetDeckFor(DM, robby, null, zach); Assert.AreEqual(robby.Profeciency.Value + robby.WeaponAdvantage - zach.ArmorCoverage, deck.Cards.Count(c => c.TypeOfCard == Card.CardType.Hit)); Assert.AreEqual(zach.ArmorCoverage, deck.Cards.Count(c => c.TypeOfCard == Card.CardType.Armor)); Assert.AreEqual(2, deck.Cards.Count(c => c.TypeOfCard == Card.CardType.Miss)); int dodgeCards = 3; zach.Conditions.Add(new Condition("Dodging", dodgeCards)); deck = attack.GetDeckFor(DM, robby, null, zach); Assert.AreEqual(robby.Profeciency.Value + robby.WeaponAdvantage - zach.ArmorCoverage, deck.Cards.Count(c => c.TypeOfCard == Card.CardType.Hit)); Assert.AreEqual(zach.ArmorCoverage, deck.Cards.Count(c => c.TypeOfCard == Card.CardType.Armor)); Assert.AreEqual(2 + dodgeCards, deck.Cards.Count(c => c.TypeOfCard == Card.CardType.Miss)); }
public List <Outcome> TakeTurn(DungeonMaster DM) { var outcomes = new List <Outcome>(); if (DM.currentSide.ID != PlayingAs) { throw new ArgumentException("Its not my turn, I am" + PlayingAs); } var randomGuy = DM.Characters.First(c => c.SideID == PlayingAs && !c.HasBeenActivated); var outcome = DM.Activate(randomGuy); outcomes.Add(outcome); outcome = DM.MoveCharacter(randomGuy, Map.Direction.S); outcomes.Add(outcome); outcome = DM.MoveCharacter(randomGuy, Map.Direction.S); outcomes.Add(outcome); outcome = DM.MoveCharacter(randomGuy, Map.Direction.S); outcomes.Add(outcome); outcome = DM.MoveCharacter(randomGuy, Map.Direction.S); outcomes.Add(outcome); outcome = DM.EndTurn(PlayingAs); outcomes.Add(outcome); return(outcomes); }
public void TestDrainVitality() { var DM = DungeonMaster.GetDebugDM(data); var drain = data.Actions.FirstOrDefault(a => a.Name == "Drain Vitality"); var robby = DM.Characters[0]; robby.Mana.Value = 0; var zach = DM.Characters[1]; zach.Mana.Value = 0; var deck = drain.GetDeckFor(DM, robby, null, zach); var hitIndex = deck.Cards.IndexOf(deck.Cards.Find(c => c.TypeOfCard == Card.CardType.Hit)); Deck.FatedDraws.Add("Drain"); var outcome = new Outcome(); drain.ResolveAction(DM, robby, null, zach, "", outcome); Assert.AreEqual("Drain Vitality", outcome.ActionTaken); Assert.IsTrue(outcome.CardsDrawn.Count == 1); Assert.IsTrue(outcome.CardsDrawn.Any(c => c.Name == "Drain")); Assert.IsTrue(robby.Mana.Value > 0); Assert.IsTrue(zach.Vitality.Value < zach.Vitality.Max); Assert.IsTrue(robby.Vitality.Value == robby.Vitality.Max); Assert.IsTrue(zach.Mana.Value == 0); }
/// <summary> /// If the player is not alive, respawns them, or ends the game. /// </summary> void FixedUpdate() { if (!Manager.Instance.playerIsAlive) { if (Manager.Instance.playerLives >= 1 && playerSpawnBox.spawnAreaClear) { playerLivesText.text = "Lives : " + Manager.Instance.playerLives; // update playerLivesUI Instantiate(playerPrefab, new Vector3(0.0F, 0.0F, 0.0F), Quaternion.identity); // spawn a player Manager.Instance.playerIsAlive = true; // set the playerIsAlive boolean to true Manager.Instance.ResetPlayerReference(); // have the manager update its reference to the player transform to the new player object } else if (Manager.Instance.playerLives <= 0 && SceneManager.GetActiveScene().buildIndex == 1) { playerLivesText.text = "Lives : " + Manager.Instance.playerLives; // update the playerLivesUI if (!gameOverCalled) { gameOverCalled = true; // set game over called to true (otherwise it will call game over every update) DungeonMaster dm = GetComponent <DungeonMaster>(); // turn off all the coroutines dm.StopAllCoroutines(); StartCoroutine(LoadGameOver()); // load game over } } } // put this in here for during demos // if anything in the game goes wrong, you can just press escape to get back to the main menu if (escape.triggered) { gameOverCalled = true; DungeonMaster dm = GetComponent <DungeonMaster>(); dm.StopAllCoroutines(); SceneManager.LoadScene(0); } }
public void Initialize() { string userInput = ""; do { userInput = DisplayMenu(); switch (userInput) { case "1": //Run Factory Example var undeadDungeonFactory = new UndeadDungeonFactory(); var undeadDungeonMaster = new DungeonMaster(undeadDungeonFactory); undeadDungeonMaster.RunAttacks(); var goblinDungeonFactory = new GoblinDungeonFactory(); var goblinDungeonMaster = new DungeonMaster(goblinDungeonFactory); goblinDungeonMaster.RunAttacks(); break; case "X": break; } } while (userInput != "X"); }
// DO NOT rename this file's namespace or class name. // However, you ARE allowed to use your own namespaces (or no namespaces at all if you prefer) in other classes. public static void Main() { DungeonMaster dungeonMaster = new DungeonMaster(); Engine engine = new Engine(dungeonMaster); engine.Run(); }
public void DMVisualizationTest() { var DM = DungeonMaster.GetDebugDM(data); string vis = DM.VisualizeWorld(); Assert.IsNotNull(vis); }
public List <DungeonMaster> GetAllPossibleStates(DungeonMaster DM, Character guy) { var states = new List <DungeonMaster>(); var moves = DM.GetPossibleMoves(guy); throw new NotImplementedException(); }
public void DeserializeAttackTest() { var DM = DungeonMaster.GetDebugDM(data); var robby = DM.Characters[0]; Assert.IsTrue(robby.Actions.Any(a => a.Name == "Attack")); //TODO: assert stuff about attack actions }
/// <summary> /// Update a specific Dungeon Master in the database /// </summary> /// <param name="dungeonMaster">Updated Dungeon Master information</param> /// <returns>Updated Dungeon Master</returns> public async Task <DungeonMasterDTO> UpdateDungeonMaster(DungeonMasterDTO dungeonMasterDTO) { DungeonMaster dungeonMaster = DeconstructDTO(dungeonMasterDTO); _context.Entry(dungeonMaster).State = EntityState.Modified; await _context.SaveChangesAsync(); return(dungeonMasterDTO); }
public Outcome ResolveEffect(DungeonMaster DM, Character user, Position posTarget, Deck deck, Card cardDrawn, List <Effect> typicalEffects) { var outcome = new Outcome(); //TODO: add slime splitting if (cardDrawn.TypeOfCard == Card.CardType.Armor) { //TODO: more elegant method if (cardDrawn.Name == "Split") { var emptySpaces = DM.GetEmptyAdjacentSquares(Pos); if (emptySpaces.Count != 0) { //int i = DungeonMaster.rand.Next(emptySpaces.Count); int i = 0; //TODO: derandomized for now for networking reasons var emptySpace = emptySpaces[i]; Vitality.Value = Vitality.Value / 2; var cloneCharacter = this.Clone() as Character; cloneCharacter.InitializeIndividual("Copy of " + Name, emptySpace, SideID, DM.GuidsInWaiting.Dequeue()); DM.CreateCharacter(cloneCharacter); } } if (cardDrawn.Name == "Burn") { if (user != null) { user.TakeDamage(DamageEffect.DamageType.Fire, 1); } } //reduce damage var damage = typicalEffects.FirstOrDefault(e => e.TypeOfEffect == Effect.EffectType.Damage) as DamageEffect; if (damage != null) { int amount = damage.GetAmount(DM, user, posTarget, this); int x = Math.Max(0, amount - ArmorProtection); var reducedDamage = new DamageEffect(damage.TypeOfDamage, x); reducedDamage.Apply(DM, user, posTarget, this, deck, cardDrawn); outcome.Message.AppendLine("Damage reduced to " + x + " by armor"); } var slimeArmor = Conditions.FirstOrDefault(c => c.Name == "Slime Armor"); if (slimeArmor != null) { slimeArmor.Value -= 1; if (slimeArmor.Value <= 0) { Conditions.Remove(slimeArmor); //TODO: auto remove if goes below 0? } } } return(outcome); }
public override Outcome Apply(DungeonMaster DM, Character user, Position posTarget, Character charTarget, Deck deck, Card cardDrawn, string optionalFeatures = null) { var outcome = new Outcome(); var affected = AffectCaster ? user: charTarget; outcome.Message.Append(affected.Name + " teleporting to " + posTarget); DM.TeleportTo(affected, posTarget); return(outcome); }
public override Outcome Apply(DungeonMaster DM, Character user, Position posTarget, Character charTarget, Deck deck, Card cardDrawn, string optionalFeatures = null) { var outcome = new Outcome(); var affected = AffectCaster ? user: charTarget; affected.AddCondition(Condition, Amount, Duration); outcome.Message.AppendLine(affected.Name + " affected by " + Condition + ":" + Amount); return(outcome); }
void OnEnable() { dm = (DungeonMaster)target; GetTarget = new SerializedObject(dm); ThisList = GetTarget.FindProperty("PossibleRooms"); }
public DungeonMaster() { sDM = this; }
public void Awake() { m_rooms = Resources.LoadAll<RoomObject>("RoomPrefabs"); s_instance = this; }
protected override void Awake() { m_dungeonMaster = GetComponent<DungeonMaster>(); base.Awake(); }