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