public static string ExportCharacterStatistics(DemolitionFalconsDbContext context)
{
var map = new DemoMap("map1");
var characters = context.Characters
.Select(c => new
{
Id = c.Id,
name = c.Name,
c.Label,
c.Description,
c.Hp,
c.Armour
})
.ToArray();
var json = JsonConvert.SerializeObject(characters, Formatting.None,
new JsonSerializerSettings()
{
ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore
}
);
return(json);
}
public void ShouldReadCreatedWadFile()
{
var fileInfo = new FileInfo(Path.GetTempFileName());
try
{
var map = DemoMap.Create();
var wadWriter = new WadWriter();
wadWriter.Append("MAP01", map);
wadWriter.SaveTo(fileInfo.FullName);
using (var wadReader = WadReader.Read(fileInfo.FullName))
{
Assert.That(wadReader.Directory.Length, Is.EqualTo(3), "Did not return correct count.");
Assert.That(
wadReader.Directory.Select(l => l.Name).ToArray(),
Is.EquivalentTo(new[]
{ new LumpName("MAP01"), new LumpName("TEXTMAP"), new LumpName("ENDMAP"), }),
"Did not return correct lump names.");
var roundTripped = MapData.LoadFrom(wadReader.GetTextmapStream("MAP01"));
Assert.That(roundTripped, Is.DeepEqualTo(map));
}
}
finally
{
if (fileInfo.Exists)
{
fileInfo.Delete();
}
}
}
public static string ExportChooseHeroStatistics(DemolitionFalconsDbContext context)
{
var map = new DemoMap("map1");
var characters = context.GameCharacters
.Select(c => new
{
map = map.Name,
name = c.Game.Name,
numberOfPlayers = c.Game.Characters.Count(),
players = c.Game.Characters.Select(st => new CharacterDto
{
Type = st.Type,
Nickname = context.Players.FirstOrDefault(p => p.Id == st.PlayerId).Username,
Name = st.Character.Name
})
})
.FirstOrDefault();
var json = JsonConvert.SerializeObject(characters, Formatting.None,
new JsonSerializerSettings()
{
ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore
}
);
return(json);
}
private DemoScene()
{
// set up camera
Camera = new Camera
{
//Zoom = 2,
Origin = new Vector2(320, 180),
Position = new Vector2(200, 400)
};
map = new DemoMap();
player = new Player(Camera);
TestEnemy enemy = new TestEnemy(new Vector2(200, 600), player);
enemy2 = new WalkingEnemy(new Vector2(295, 365), player);
//enemy2 = new WalkingEnemy(new Vector2(250, 400), player);
Item item = new Item(player, new Vector2(100, 500));
children.Add(map);
children.Add(player);
//children.Add(enemy);
children.Add(enemy2);
children.Add(item);
physical = new PhysicsGroup(PhysicsGroupType.Physical);
physical.Add(map);
physical.Add(player);
//physical.Add(enemy);
physical.Add(enemy2);
writer = new FragmentWriter("Fonts/TooMuchInk", new Rectangle(100, 450, 200, 200), Color.White);
writer.SetText(Fragment.Parse(example));
}
public DiceFront Get()
{
var map = new DemoMap("map1");
var dice = new DiceDto();
return(new DiceFront(dice.RollDice()));
}
public IEnumerable <CharacterFront> Get()
{
var map = new DemoMap("map1");
var character = this.dbContext.GameCharacters
.Select(c => new CharacterFront(c.Game.Name, map.Name, c.Game.Characters.Count()))
.ToArray();
return(character);
}
public void ShouldHandleParsingDemoMap()
{
var map = DemoMap.Create();
using var stream = new MemoryStream();
map.WriteTo(stream);
stream.Position = 0;
using var textReader = new StreamReader(stream, Encoding.ASCII);
var lexer = new UnifiedLexer(textReader);
var result = UdmfParser.Parse(lexer.Scan()).ToArray();
}
public void HaveFun(Game room, StringBuilder sb, string preferredMap, bool isSingle, int singleCharId)
{
int roomId = room.Id;
//Create dice
DiceDto dice = new DiceDto();
//Add Characters to the room
var game = context.Games.FirstOrDefault(g => g.Id == room.Id);
var characters = new List <Character>();
foreach (var gc in game.Characters)
{
var character = gc.Character;
characters.Add(character);
}
if (preferredMap == "demomap")
{
var map = new DemoMap("map1");
var playableMap = map.GenerateMap();
SetOnStart(room, playableMap, roomId);// set all chars on start
if (!isSingle)
{
ProceedGame(game, sb, playableMap, characters, dice, roomId);
}
else
{
var gaChar = context.GameCharacters.FirstOrDefault(gc => gc.CharacterId == singleCharId && gc.GameId == roomId);
var singlePlayer = new SinglePlayer(context, reader, writer, numberGenerator);
singlePlayer.StartSinglePlayer(dice, gaChar, playableMap, characters, sb, roomId, game);
}
}
else if (preferredMap == "firstmap")
{
var firstMap = new FirstMapFrontEnd();
var generatedFirstMap = firstMap.GenerateFirstMap();
SetOnStart(room, generatedFirstMap, roomId);// set all chars on start
if (!isSingle)
{
ProceedGame(game, sb, generatedFirstMap, characters, dice, roomId);
}
else
{
var gaChar = context.GameCharacters.FirstOrDefault(gc => gc.CharacterId == singleCharId && gc.GameId == roomId);
var singlePlayer = new SinglePlayer(context, reader, writer, numberGenerator);
singlePlayer.StartSinglePlayer(dice, gaChar, generatedFirstMap, characters, sb, roomId, game);
}
}
}
public void ShouldRoundTripDemoMap()
{
var map = DemoMap.Create();
using var stream = new MemoryStream();
map.WriteTo(stream);
stream.Position = 0;
using var textReader = new StreamReader(stream, Encoding.ASCII);
var roundTripped = UdmfSemanticAnalyzer.ReadMapData(UdmfParser.Parse(new UnifiedLexer(textReader).Scan()));
UdmfComparison.AssertEqual(roundTripped, map);
}
public void ShouldHandleParsingDemoMap()
{
var map = DemoMap.Create();
using (var stream = new MemoryStream())
{
map.WriteTo(stream);
stream.Position = 0;
using (var textReader = new StreamReader(stream, Encoding.ASCII))
{
var result = UdmfParser.TranslationUnit.ParseOrThrow(textReader);
}
}
}
public void ShouldHandleLexingDemoMap()
{
var map = DemoMap.Create();
using (var stream = new MemoryStream())
{
map.WriteTo(stream);
stream.Position = 0;
using (var textReader = new StreamReader(stream, Encoding.ASCII))
{
var lexer = new UdmfLexer(textReader);
var result = lexer.Scan().ToArray();
}
}
}
public void ShouldHandleParsingDemoMap()
{
var map = DemoMap.Create();
using (var stream = new MemoryStream())
{
map.WriteTo(stream);
stream.Position = 0;
using (var textReader = new StreamReader(stream, Encoding.ASCII))
{
var text = textReader.ReadToEnd();
var result = UdmfParser.GlobalExpressions.Parse(UdmfTokenizerRules.Tokenizer.Tokenize(text));
}
}
}
public void ShouldCreateWadFile()
{
var fileInfo = new FileInfo(Path.GetTempFileName());
try
{
var wad = new WadWriter();
wad.Append("MAP01", DemoMap.Create());
wad.SaveTo(fileInfo.FullName);
}
finally
{
if (fileInfo.Exists)
{
fileInfo.Delete();
}
}
}
public void ShouldRoundTripDemoMap()
{
var map = DemoMap.Create();
using (var stream = new MemoryStream())
{
map.WriteTo(stream);
stream.Position = 0;
using (var textReader = new StreamReader(stream, Encoding.ASCII))
{
var sa = new UdmfSyntaxAnalyzer();
var roundTripped = UdmfParser.Parse(sa.Analyze(new UdmfLexer(textReader)));
Assert.That(roundTripped, Is.DeepEqualTo(map));
}
}
}
public void ShouldHandleParsingDemoMap()
{
var map = DemoMap.Create();
using (var stream = new MemoryStream())
{
map.WriteTo(stream);
stream.Position = 0;
using (var textReader = new StreamReader(stream, Encoding.ASCII))
{
var lexer = new UdmfLexer(textReader);
var parser = new UdmfParser(lexer);
ParseResult result = parser.Parse();
Assert.That(result.IsSuccess, Is.True);
}
}
}
public CharacterFront Get()
{
var map = new DemoMap("map1");
CharacterFront character = this.dbContext.GameCharacters
.Select(c => new CharacterFront
{
Map = map.Name,
Name = c.Game.Name,
NumberOfPlayers = c.Game.Characters.Count(),
Players = c.Game.Characters.Select(st => new CharacterDto
{
Type = st.Type,
Nickname = this.dbContext.Players.FirstOrDefault(p => p.Id == st.PlayerId).Username,
Name = st.Character.Name
})
})
.FirstOrDefault();
return(character);
}
public static string ExportGameAndMapStatistics(DemolitionFalconsDbContext context)
{
var map = new DemoMap("map1");
var characters = context.GameCharacters
.Select(c => new
{
name = c.Game.Name,
map = map.Name,
numberOfOpponents = c.Game.Characters.Count()
})
.FirstOrDefault();
var json = JsonConvert.SerializeObject(characters, Formatting.None,
new JsonSerializerSettings()
{
ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore
}
);
return(json);
}
public void ShouldHandleParsingDemoMap()
{
var map = DemoMap.Create();
using (var fs = File.OpenWrite("text.udmf"))
{
map.WriteTo(fs);
}
using (var stream = new MemoryStream())
{
map.WriteTo(stream);
stream.Position = 0;
using (var textReader = new StreamReader(stream, Encoding.ASCII))
{
var lexer = new UdmfLexer(textReader);
var result = UdmfParser.TranslationUnit.ParseOrThrow(lexer.Scan());
}
}
}
public void ShouldHandleParsingDemoMap()
{
var map = DemoMap.Create();
using (var fs = File.OpenWrite(Path.Combine(TestContext.CurrentContext.TestDirectory, "text.udmf")))
{
map.WriteTo(fs);
}
using (var stream = new MemoryStream())
{
map.WriteTo(stream);
stream.Position = 0;
using (var textReader = new StreamReader(stream, Encoding.ASCII))
{
var lexer = new UdmfLexer(textReader);
var result = UdmfParser.Parse(lexer.Scan()).ToArray();
}
}
}
public void TriArrayErrorCase()
{
PhysicsGroup physicsGroup = new PhysicsGroup(PhysicsGroupType.Physical);
DemoMap demoMap = new DemoMap();
Player player = new Player(new RBGNature.Camera());
player.collision = new Circle()
{
Radius = 10,
Mass = 1,
Position = new Vector2(170.716476f, 303.425659f),
Velocity = new Vector2(-0.17978698f, 0.0744702f)
};
physicsGroup.Add(demoMap);
physicsGroup.Add(player);
physicsGroup.Collide(16.6488f);
player.Update(new GameTime());
Assert.IsTrue(player.collision.Position.X + player.collision.Position.Y > 460 + Math.Sqrt(2) * 10);
}
public void BoxDemo() =>
Load(CreateWadContents(new Func <TextureQueue, MapData>[] {
tq => DemoMap.Create()
}));
public void ShouldRoundTripDemoMap()
{
AssertRoundTrip(DemoMap.Create());
}
// Update is called once per frame
void Update()
{
/*if (!GameObject.activeSelf)
* {
* Debug.Log("Sliding menu not active");
* return;
* }*/
// Debug.Log("Update sliding menu id: " + m_Id);
// Debug.Log("m_bSlidingUpEnabled: " + m_bSlidingUpEnabled + " m_bSlidingDownEnabled: " + m_bSlidingDownEnabled);
if (m_bSliding)
{
m_Value = ((m_SlidingToValue - m_Value) * m_SlidingSpeed2) + m_Value;
float dif = (m_SlidingToValue - m_Value);
if (dif < 0.0f)
{
dif *= -1.0f;
}
if (dif < 0.02f)
{
m_Value = m_SlidingToValue;
m_bSliding = false;
DemoMap map = m_Handler.GetComponent <DemoMap>();
map.SlidingMenuFinished(m_Id);
}/**/
}
float ratio = (float)Screen.width / (float)Screen.height;
if (m_bVertical == false)
{
ratio = 1.0f;//(float)Screen.height / (float)Screen.width;
}
float value = m_Value;
float offset = 0.0f;
m_bDraggingOverThreshold = false;
if (m_DraggingEnabled)
{
if (Input.GetMouseButtonDown(0))
{
Debug.Log("#### Sliding Menu down #####");
m_MousePositionDown = Input.mousePosition;
if (IsPointInRT(m_MousePositionDown, m_Back.GetComponent <RectTransform>()) &&
(!m_bBackIgnoreTouch || m_BackIgnoreTouch == null || !IsPointInRT(m_MousePositionDown, m_BackIgnoreTouch.GetComponent <RectTransform>())))
{
m_bDragging = true;
}
}
if (Input.GetMouseButton(0) && m_bDragging)
{
offset = Input.mousePosition.y - m_MousePositionDown.y;
if (m_bVertical == false)
{
float vertical = offset;
offset = Input.mousePosition.x - m_MousePositionDown.x;
if (vertical > 70.0f)
{
offset = 0.0f;
m_MousePositionDown.y = -100000;
}
}
float vecx = Input.mousePosition.x - m_MousePositionDown.x;
float vecy = Input.mousePosition.y - m_MousePositionDown.y;
if (vecx < 0.0f)
{
vecx *= -1.0f;
}
if (vecy < 0.0f)
{
vecy *= -1.0f;
}
if (m_bVertical == false)
{
if (vecy > vecx)
{
offset = 0.0f;
}
}
else
{
if (vecx > vecy)
{
offset = 0.0f;
}
}
float offsetsign = offset;
if (m_bVertical)
{
offset /= Screen.height;
}
else
{
offset /= Screen.width;
}
if (m_bSlidingUpEnabled == false)
{
if (offset > 0.0f)
{
offset = 0.0f;
offsetsign = 0.0f;
}
}
if (m_bSlidingDownEnabled == false)
{
if (offset < 0.0f)
{
offset = 0.0f;
offsetsign = 0.0f;
}
}
// Debug.Log("Offset menu dragging: " + offsetsign);
if (offsetsign < 0.0f)
{
offsetsign *= -1.0f;
}
if (offsetsign > 10.0f)
{
m_bDraggingOverThreshold = true;
DemoMap map = m_Handler.GetComponent <DemoMap>();
map.SlidingMenu();
}
if (offsetsign < m_SliddingThreshold)
{
offset = 0.0f;
}
}
else // Stopped dragging
{
if (m_bDragging)
{
float vecx = Input.mousePosition.x - m_MousePositionDown.x;
float vecy = Input.mousePosition.y - m_MousePositionDown.y;
offset = Input.mousePosition.y - m_MousePositionDown.y;
if (m_bVertical == false)
{
float vertical = offset;
// if (vertical < 0.0f) vertical *= -1.0f;
offset = Input.mousePosition.x - m_MousePositionDown.x;
if (vertical > 70.0f)
{
offset = 0.0f;
m_MousePositionDown.y = -100000;
}
}
if (vecx < 0.0f)
{
vecx *= -1.0f;
}
if (vecy < 0.0f)
{
vecy *= -1.0f;
}
if (m_bVertical == false)
{
Debug.Log("Sliding menu release vertical== false vecx: " + vecx + " vecy: " + vecy);
if (vecy > vecx)
{
offset = 0.0f;
Debug.Log("offset = 0.0");
}
}
else
{
Debug.Log("Sliding menu release vertical==true vecx: " + vecx + " vecy: " + vecy);
if (vecx > vecy)
{
offset = 0.0f;
Debug.Log("offset = 0.0");
}
}
if (offset > m_SliddingThreshold)
{
if (m_bSlidingUpEnabled)
{
Debug.Log("Close menu");
DemoMap map = m_Handler.GetComponent <DemoMap>();
map.CloseMenu(m_Id);
if (m_bVertical)
{
offset /= Screen.height;
}
else
{
offset /= Screen.width;
}
offset /= ratio;
m_Value -= offset;
value -= offset;
}
}
else if (offset < -m_SliddingThreshold)
{
if (m_bSlidingDownEnabled)
{
Debug.Log("Open menu");
DemoMap map = m_Handler.GetComponent <DemoMap>();
map.OpenMenu(m_Id);
if (m_bVertical)
{
offset /= Screen.height;
}
else
{
offset /= Screen.width;
}
offset /= ratio;
m_Value -= offset;
value -= offset;
}
}
}
offset = 0.0f;
m_bDragging = false;
}
}
if (m_bVertical)
{
menu.anchorMin = new Vector2(0.5f, 1.0f - value * ratio + offset);
menu.anchorMax = new Vector2(0.5f, 1.0f - value * ratio + offset);
}
else
{
menu.anchorMin = new Vector2(1.0f - value * ratio + offset, 0.5f);
menu.anchorMax = new Vector2(1.0f - value * ratio + offset, 0.5f);
}
}
