diff options
| author | GeorgeAbbott <57576261+GeorgeAbbott@users.noreply.github.com> | 2020-09-06 18:09:11 +0100 |
|---|---|---|
| committer | GitHub <noreply@github.com> | 2020-09-06 18:09:11 +0100 |
| commit | 44c1454eed3a2710bbf087c721cc4bd7c56fe1b4 (patch) | |
| tree | 54ff5cf753774be83feae2e15672ed4fa26ad4f1 | |
Add files via upload
| -rw-r--r-- | Class War.csproj | 78 | ||||
| -rw-r--r-- | Constants.cs | 36 | ||||
| -rw-r--r-- | Enemy.cs | 218 | ||||
| -rw-r--r-- | Game1.cs | 512 | ||||
| -rw-r--r-- | Icon.ico | bin | 0 -> 147541 bytes | |||
| -rw-r--r-- | InputHandler.cs | 97 | ||||
| -rw-r--r-- | MainChara.cs | 65 | ||||
| -rw-r--r-- | Menu.cs | 137 | ||||
| -rw-r--r-- | Program.cs | 22 | ||||
| -rw-r--r-- | Sprite.cs | 14 | ||||
| -rw-r--r-- | Timer.cs | 47 | ||||
| -rw-r--r-- | app.manifest | 42 |
12 files changed, 1268 insertions, 0 deletions
diff --git a/Class War.csproj b/Class War.csproj new file mode 100644 index 0000000..86a108d --- /dev/null +++ b/Class War.csproj @@ -0,0 +1,78 @@ +<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+ <Import Project="$(MSBuildExtensionsPath)\MonoGame\v3.0\MonoGame.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\MonoGame\v3.0\MonoGame.Common.props')" />
+ <PropertyGroup>
+ <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+ <Platform Condition=" '$(Platform)' == '' ">x86</Platform>
+ <ProductVersion>8.0.30703</ProductVersion>
+ <SchemaVersion>2.0</SchemaVersion>
+ <ProjectGuid>{C1D2D54B-62BF-43AE-B0AC-970731BA20D9}</ProjectGuid>
+ <OutputType>WinExe</OutputType>
+ <AppDesignerFolder>Properties</AppDesignerFolder>
+ <RootNamespace>Class_War</RootNamespace>
+ <AssemblyName>Class War</AssemblyName>
+ <FileAlignment>512</FileAlignment>
+ <MonoGamePlatform>Windows</MonoGamePlatform>
+ <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
+ </PropertyGroup>
+ <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
+ <PlatformTarget>x86</PlatformTarget>
+ <DebugSymbols>true</DebugSymbols>
+ <DebugType>full</DebugType>
+ <Optimize>false</Optimize>
+ <OutputPath>bin\$(MonoGamePlatform)\$(Platform)\$(Configuration)\</OutputPath>
+ <DefineConstants>DEBUG;TRACE;WINDOWS</DefineConstants>
+ <ErrorReport>prompt</ErrorReport>
+ <WarningLevel>4</WarningLevel>
+ </PropertyGroup>
+ <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
+ <PlatformTarget>x86</PlatformTarget>
+ <DebugType>pdbonly</DebugType>
+ <Optimize>true</Optimize>
+ <OutputPath>bin\$(MonoGamePlatform)\$(Platform)\$(Configuration)\</OutputPath>
+ <DefineConstants>TRACE;WINDOWS</DefineConstants>
+ <ErrorReport>prompt</ErrorReport>
+ <WarningLevel>4</WarningLevel>
+ </PropertyGroup>
+ <PropertyGroup>
+ <ApplicationIcon>Icon.ico</ApplicationIcon>
+ </PropertyGroup>
+ <PropertyGroup>
+ <ApplicationManifest>app.manifest</ApplicationManifest>
+ </PropertyGroup>
+ <ItemGroup>
+ <Compile Include="Constants.cs" />
+ <Compile Include="Enemy.cs" />
+ <Compile Include="Game1.cs" />
+ <Compile Include="InputHandler.cs" />
+ <Compile Include="MainChara.cs" />
+ <Compile Include="Menu.cs" />
+ <Compile Include="Program.cs" />
+ <Compile Include="Properties\AssemblyInfo.cs" />
+ <Compile Include="Sprite.cs" />
+ <Compile Include="Timer.cs" />
+ </ItemGroup>
+ <ItemGroup>
+ <Reference Include="MonoGame.Framework">
+ <HintPath>$(MonoGameInstallDirectory)\MonoGame\v3.0\Assemblies\Windows\MonoGame.Framework.dll</HintPath>
+ </Reference>
+ <Reference Include="System" />
+ <Reference Include="System.Xml" />
+ </ItemGroup>
+ <ItemGroup>
+ <Content Include="Icon.ico" />
+ </ItemGroup>
+ <ItemGroup>
+ <MonoGameContentReference Include="Content\Content.mgcb" />
+ <None Include="app.manifest" />
+ </ItemGroup>
+ <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+ <Import Project="$(MSBuildExtensionsPath)\MonoGame\v3.0\MonoGame.Content.Builder.targets" />
+ <!-- To modify your build process, add your task inside one of the targets below and uncomment it. + Other similar extension points exist, see Microsoft.Common.targets. + <Target Name="BeforeBuild"> + </Target> + <Target Name="AfterBuild"> + </Target> + -->
+</Project>
\ No newline at end of file diff --git a/Constants.cs b/Constants.cs new file mode 100644 index 0000000..f46874d --- /dev/null +++ b/Constants.cs @@ -0,0 +1,36 @@ +using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+
+namespace Class_War
+{
+ public static class Constants
+ {
+ public const string Consolas12 = "Consolas12";
+
+ public const string DefaultFont = Consolas12;
+
+ public const int Level1MaxEnemyCount = 10;
+ public const int Level1EnemyHealth = 100;
+
+ public const string MainCharacterSpriteImage = "maincharaimage";
+ public static readonly Vector2 MainCharacterStartingPosition;
+
+ public const int LifeLostScreenDuration = 3;
+ public const int AfterLifeLostImmunityTime = LifeLostScreenDuration + 5;
+
+ public const int RightMostEdge = 800;
+ public const int BottomMostEdge = 500;
+
+
+ static Constants ()
+ {
+ MainCharacterStartingPosition = new Vector2(330, 375); // TODO: add
+ }
+
+ }
+}
diff --git a/Enemy.cs b/Enemy.cs new file mode 100644 index 0000000..5e343b2 --- /dev/null +++ b/Enemy.cs @@ -0,0 +1,218 @@ +using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+using Microsoft.Xna.Framework.Graphics;
+using Microsoft.Xna.Framework.Design;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Content;
+
+using static Class_War.Constants;
+
+namespace Class_War
+{
+
+ enum Direction
+ {
+ Left,
+ Right,
+ Up,
+ Down
+ }
+
+
+ class Enemy : Sprite
+ {
+ bool OutOfBounds
+ {
+ get
+ {
+ // OutOfBounds is where
+ /*
+ * -> The TopLeft X is beyond the screen's RIGHT edge, or ...
+ * -> The TopRight X is beyond the screen's LEFT edge, or ...
+ * -> The Bottom Y is beyond the screen's TOPMOST edge, or ...
+ * -> The Top Y is beyond the screen's BOTTOMMOST edge
+ */
+
+ if (position.X > RightMostEdge+12) return true; //
+ else if (Vector2.Add(position, sizeOfString).X < 0) return true;
+ else if (Vector2.Add(position, sizeOfString).Y < 0) return true;
+ else if (position.Y > BottomMostEdge+12) return true; //
+ else return false;
+ }
+ }
+
+ public List<Vector2> Borders
+ {
+ get
+ {
+ Vector2 bottomright = new Vector2();
+ bottomright.X = (position.X + sizeOfString.X);
+ bottomright.Y = (position.Y + sizeOfString.Y);
+ return new List<Vector2>() { position, bottomright };
+ }
+ }
+
+ ContentManager Content;
+ int hp;
+ string keyword;
+ public Vector2 position;
+ SpriteFont font;
+ public int points;
+ Color color;
+ Vector2 sizeOfString;
+ float speed;
+ public Direction direction;
+ bool isDestroyed = false;
+ public bool IsDestroyed { get => isDestroyed; set => isDestroyed = value; }
+ Random random = new Random();
+
+ DateTime timeOfLastBullet = DateTime.Now;
+
+
+
+
+ public Enemy
+ (ContentManager Content, int hp, string keyword,
+ string font, Color color, double speed, int level,
+ bool isException, Vector2 position, Direction direction)
+ {
+ this.Content = Content;
+ this.hp = hp * (isException ? 2 : 1);
+ this.keyword = keyword;
+ this.font = Content.Load<SpriteFont>(font);
+ this.color = color;
+ this.sizeOfString = this.font.MeasureString(keyword);
+ this.points = Convert.ToInt32(Convert.ToDouble(level) * speed);
+ this.speed = (float)speed;
+ this.direction = direction;
+ this.position = position;
+ }
+
+ public void Update(ref List<Bullet> bullets)
+ // containingList is the list containing this object, to allow for it to destroy itself when out of bounds.
+ {
+ Move();
+ if (OutOfBounds)
+ IsDestroyed = true;
+
+ // Create bullets
+ if (DateTime.Now - timeOfLastBullet > TimeSpan.FromSeconds(
+ (((15*random.NextDouble()) - (0.4*speed) + 1) > 0.1) ? ((15*random.NextDouble()) - (0.4 * speed) + 1) : 0.05))
+ {
+ timeOfLastBullet = DateTime.Now;
+ bullets.Add(new Bullet(Content, position,
+ ((direction == Direction.Left || direction == Direction.Right) ? Direction.Down : new List<Direction>() { Direction.Left, Direction.Right }[random.Next(0,1)])
+ , 5, false));
+ }
+
+ }
+
+ public void Move()
+ {
+ if (direction == Direction.Left)
+ {
+ this.position.X -= speed;
+ }
+ if (direction == Direction.Right)
+ {
+ this.position.X += speed;
+ }
+ if (direction == Direction.Up)
+ {
+ this.position.Y -= speed;
+ }
+ if (direction == Direction.Down)
+ {
+ this.position.Y += speed;
+ }
+ }
+
+ public void Draw(SpriteBatch sb)
+ {
+ sb.DrawString(font, keyword, position, color);
+ }
+
+ }
+
+ class Bullet
+ {
+ bool OutOfBounds
+ {
+ get
+ {
+ // OutOfBounds is where
+ /*
+ * -> The TopLeft X is beyond the screen's RIGHT edge, or ...
+ * -> The TopRight X is beyond the screen's LEFT edge, or ...
+ * -> The Bottom Y is beyond the screen's TOPMOST edge, or ...
+ * -> The Top Y is beyond the screen's BOTTOMMOST edge
+ */
+
+ if (position.X > GraphicsAdapter.DefaultAdapter.CurrentDisplayMode.Width) return true;
+ else if ((position).X < 0) return true;
+ else if ((position).Y < 0) return true;
+ else if (position.Y > GraphicsAdapter.DefaultAdapter.CurrentDisplayMode.Height) return true;
+ else return false;
+ }
+ }
+
+
+
+ public Vector2 position;
+ public bool isPlayersBullet;
+ Direction direction;
+ int speed;
+
+ Texture2D image;
+
+ bool isDestroyed = false;
+ public bool IsDestroyed { get => isDestroyed ; set => isDestroyed = value; }
+
+ public void Move(bool autoUpdate = true)
+ {
+ if (direction == Direction.Left)
+ {
+ this.position.X -= speed;
+ }
+ if (direction == Direction.Right)
+ {
+ this.position.X += speed;
+ }
+ if (direction == Direction.Up)
+ {
+ this.position.Y -= speed;
+ }
+ if (direction == Direction.Down)
+ {
+ this.position.Y += speed;
+ }
+
+ if (autoUpdate)
+ Update();
+ }
+
+ public void Update()
+ {
+ if (OutOfBounds)
+ IsDestroyed = true;
+ }
+
+ public void Draw(SpriteBatch sb)
+ {
+ sb.Draw(image, position, Color.White);
+ }
+
+ public Bullet(ContentManager Content, Vector2 position, Direction direction, int speed, bool isPlayersBullet)
+ {
+ this.position = position;
+ this.direction = direction;
+ this.speed = speed;
+ this.isPlayersBullet = isPlayersBullet;
+ this.image = Content.Load<Texture2D>("bullet");
+ }
+ } // End of Class Bracket
+}
diff --git a/Game1.cs b/Game1.cs new file mode 100644 index 0000000..a6f96b0 --- /dev/null +++ b/Game1.cs @@ -0,0 +1,512 @@ +using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using Microsoft.Xna.Framework.Input;
+using static Class_War.Constants;
+using System.Diagnostics;
+using System.Collections.Generic;
+using System;
+
+
+namespace Class_War
+{
+ /// <summary>
+ /// This is the main type for your game.
+ /// </summary>
+ public class Game1 : Game
+ {
+ GraphicsDeviceManager graphics;
+ SpriteBatch spriteBatch;
+
+ SpriteFont Consolas12SF;
+
+ Random random = new Random();
+
+ InputHandler inputHandler;
+
+ int score;
+ byte level;
+ int enemiesSpawnedForLevel;
+ int maxEnemiesForCurrLevel;
+ bool isPaused;
+ DateTime startTime;
+ bool newLevel;
+ bool beginNewLevel = false;
+ int lives = 3;
+ bool lifeLost; // TODO: initialize these
+ bool inMenu = false;
+ bool isShill = false;
+ bool usesBackgroundImage = false;
+
+ Texture2D codeBackgroundImage;
+ Texture2D shillBackgroundImage;
+
+
+ DateTime lifeLostTime;
+
+ Timer collisionTimer = new Timer();
+
+ Menu menu;
+
+ MainChara mainchara;
+ List<Enemy> enemies;
+ List<Bullet> bullets;
+
+
+ List<string> csharpKeywords;
+ List<string> assemblyKeywords;
+ List<string> cppKeywords;
+ List<string> keywords;
+ List<string> exceptions;
+
+ public bool IsCollision(List<Vector2> borders, Vector2 point)
+ {
+ // If point within the borders, return true.
+ if (point.X >= borders[0].X && point.X <= borders[1].X && point.Y >= borders[0].Y && point.Y <= borders[1].Y) return true;
+ else return false;
+
+ } // TODO: add
+
+
+ public Game1()
+ {
+ graphics = new GraphicsDeviceManager(this);
+ Content.RootDirectory = "Content";
+ }
+
+ /// <summary>
+ /// Allows the game to perform any initialization it needs to before starting to run.
+ /// This is where it can query for any required services and load any non-graphic
+ /// related content. Calling base.Initialize will enumerate through any components
+ /// and initialize them as well.
+ /// </summary>
+ protected override void Initialize()
+ {
+ // TODO: Add your initialization logic here
+
+ isPaused = false;
+ mainchara = new MainChara(Content, MainCharacterSpriteImage, MainCharacterStartingPosition);
+
+ enemies = new List<Enemy>();
+ bullets = new List<Bullet>();
+
+ menu = new Menu(Content, Consolas12);
+
+ // Level and Enemy loading logic
+ newLevel = true;
+ startTime = DateTime.Now;
+ level = 1;
+ score = 0;
+ maxEnemiesForCurrLevel = Level1MaxEnemyCount;
+
+ inputHandler = new InputHandler();
+
+ shillBackgroundImage = Content.Load<Texture2D>("shillbg");
+ codeBackgroundImage = Content.Load<Texture2D>("codebg");
+
+ lifeLost = false;
+ lifeLostTime = DateTime.Now.Subtract(new TimeSpan(0, 0, AfterLifeLostImmunityTime));
+
+ // TODO: actually add keyword loading mechanism
+ csharpKeywords = new List<string>()
+ { "abstract", "base", "bool", "break", "byte", "case", "catch",
+ "char", "checked", "class", "const", "continue", "decimal", "default",
+ "delegate", "do", "double", "else", "enum", "event", "explicit",
+ "extern", "false", "finally", "fixed", "float", "for", "foreach",
+ "goto", "if", "implicit", "in", "int", "interface", "internal",
+ "is", "lock", "long", "namespace", "new", "null", "object", "operator",
+ "out", "override", "params", "private", "protected", "public",
+ "readonly", "ref", "return", "sbyte", "sealed", "short", "sizeof",
+ "stackalloc", "static", "string", "struct", "switch", "this",
+ "throw", "true", "try", "typeof", "uint", "ulong", "unchecked", "unsafe", "ushort",
+ "using", "virtual", "void", "volatile", "while"};
+ assemblyKeywords = new List<string>()
+ {
+ "aaa", "aad", "aam", "aas", "adc", "add", "and", "call", "cbw",
+ "clc", "cld", "cli", "cmc", "cmp", "cmpsb", "cmpsw", "cwd", "daa",
+ "das", "dec", "div", "esc", "hlt", "idiv", "imul", "in", "inc",
+ "int", "into", "iret", "ja", "jae", "jb", "jbe", "jc", "je", "jg",
+ "jge", "jl", "jle", "jna", "jnae", "jnb", "jnbe", "jnc", "jne", "jng",
+ "jnge", "jnl", "jnle", "jno", "jnp", "jns", "jnz", "jo", "jp", "jpe",
+ "jpo", "js", "jz", "jcxz", "jmp", "lahf", "lds", "lea", "les", "lock",
+ "lodsb", "lodsw", "loop", "mov", "movsb", "movsw", "mul", "neg",
+ "nop", "not", "or", "out", "pop", "popf", "push", "pushf", "rcl",
+ "rcr", "rep", "repe", "repne", "repnz", "repz", "retn", "retf",
+ "ret", "rol", "ror", "sahf", "sal", "sar", "sbb", "scasb", "scasw",
+ "shl", "shr", "stc", "std", "sti", "stosb", "stosw", "sub",
+ "test", "wait", "xchg", "xlat", "xor"
+ };
+ cppKeywords = new List<string>() { "alignas", "alignof", "and",
+ "and_eq", "asm", "atomic_cancel", "atomic_commit", "atomic_noexcept",
+ "auto", "bitand", "bitor", "bool", "break", "case", "catch", "char",
+ "char8_t", "char16_t", "char32_t", "class", "compl", "concept",
+ "const", "consteval", "constexpr", "constinit", "const_cast",
+ "continue", "co_await", "co_return", "co_yield", "decltype",
+ "default", "delete", "do", "double", "dynamic_cast", "else",
+ "enum", "explicit","export", "extern", "false", "float",
+ "for", "friend", "goto", "if", "inline", "int", "long",
+ "mutable", "namespace", "new", "noexcept", "not", "not_eq",
+ "nullptr", "operator", "or", "or_eq", "private", "protected",
+ "register", "reinterpret_cast", "requires", "return", "short",
+ "signed", "sizeof", "static", "static_assert", "static_cast",
+ "struct", "switch", "this", "template", "thread_local", "throw",
+ "true", "try", "typedef", "typeid", "typename", "union", "unsigned",
+ "using", "virtual", "void", "volatile", "wchar_t", "while",
+ "xor", "xor_eq", "final", "override", "ifdef", "elif", "endif", "pragma",
+ "undef", "define", "error", "line", "include", "export", "import",
+ "module"};
+
+ keywords = csharpKeywords;
+
+
+
+ exceptions = new List<string>();
+ exceptions.Add("NullReferenceException");
+
+
+ // Add Level One enemies
+
+
+
+ base.Initialize();
+ }
+
+ /// <summary>
+ /// LoadContent will be called once per game and is the place to load
+ /// all of your content.
+ /// </summary>
+ protected override void LoadContent()
+ {
+ // Create a new SpriteBatch, which can be used to draw textures.
+ spriteBatch = new SpriteBatch(GraphicsDevice);
+ Consolas12SF = Content.Load<SpriteFont>(DefaultFont);
+
+ // TODO: use this.Content to load your game content here
+ }
+
+ /// <summary>
+ /// UnloadContent will be called once per game and is the place to unload
+ /// game-specific content.
+ /// </summary>
+ protected override void UnloadContent()
+ {
+ // TODO: Unload any non ContentManager content here
+ }
+
+ /// <summary>
+ /// Allows the game to run logic such as updating the world,
+ /// checking for collisions, gathering input, and playing audio.
+ /// </summary>
+ /// <param name="gameTime">Provides a snapshot of timing values.</param>
+ protected override void Update(GameTime gameTime)
+ {
+ if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed || Keyboard.GetState().IsKeyDown(Keys.Escape))
+ Exit();
+
+ if (newLevel)
+ { // If newLevel begin the timer process, to regularly spawn the new enemies.
+ if ((DateTime.Now - startTime) > TimeSpan.FromSeconds(30d / maxEnemiesForCurrLevel))// SystemOverFlowexception here.
+ {
+ // Adequate time has passed, so spawn in a new enemy
+ string text = keywords[random.Next(keywords.Count)];
+ bool isException = false;
+
+ // Generate position and is left to right (or up and down)
+ Vector2 position = new Vector2(2,2); // Just to stop the error basically, position is overridden later
+ Direction direction;
+
+ // Testing for Random number gen
+ /*Debug.WriteLine(new string('\n', 20));
+ for (int amountoftimestodebugforwiththisthing = 0; amountoftimestodebugforwiththisthing < 150; amountoftimestodebugforwiththisthing++)
+ {
+ Debug.Write($"{(Direction)random.Next(0, 4)} - ");
+ }
+ Debug.WriteLine(new string('\n', 10));*/
+
+ if (level <= 5)
+ { // Can only declare left to right positions.
+ direction = (Direction)random.Next(0, 2); // Only generating 1
+ }
+ else
+ direction = (Direction)random.Next(0, 4); // Only generating 3
+
+ Debug.WriteLine($"\t\t\t\tCreated new Direction -> {direction.ToString()}");
+
+ if (direction == Direction.Left)
+ {
+ position = new Vector2(RightMostEdge+10f,
+ random.Next(0, BottomMostEdge-75));
+ }
+ else if (direction == Direction.Right)
+ {
+ position = new Vector2(-10f, random.Next(0, BottomMostEdge-75));
+ }
+ else if (direction == Direction.Down)
+ {
+ position = new Vector2(random.Next(0, GraphicsAdapter.DefaultAdapter.CurrentDisplayMode.Width), -10f);
+ }
+ else if (direction == Direction.Up)
+ {
+ position = new Vector2(random.Next(0, RightMostEdge-5),
+ BottomMostEdge + 10f);
+ }
+
+
+
+
+ if (exceptions.Contains(text)) isException = true;
+ enemies.Add(new Enemy(Content, Level1EnemyHealth * level, text,
+ Consolas12,
+ Color.White,
+ random.NextDouble() + 0.3 + (level*0.15),
+ level, isException, position, direction));
+
+ enemiesSpawnedForLevel++;
+ if (enemiesSpawnedForLevel == maxEnemiesForCurrLevel) newLevel = false; // Once everything is spawned, no longer new level
+ }
+
+ }
+ // Begin the New Level once all Enemies down
+ if (!newLevel && (enemies.Count == 0)) // If all for this level spawned and disappeared out of list
+ {
+ beginNewLevel = true;
+ }
+
+
+ // Updating spawning logic for the next level
+ if (enemiesSpawnedForLevel >= maxEnemiesForCurrLevel && beginNewLevel)
+ { // Time for each spawning wave will be 30 seconds
+ level++;
+ newLevel = true;
+ beginNewLevel = false; // the level is begun-- this is set to true again once all enemies are gone
+ startTime = DateTime.Now;
+ enemiesSpawnedForLevel = 0;
+ maxEnemiesForCurrLevel = ((Level1MaxEnemyCount) + maxEnemiesForCurrLevel);
+ }
+
+
+
+ // Handle Input
+ inputHandler.ReadInput();
+ Debug.WriteLine("Jello"); // This is working every loop
+
+ /*if (inputHandler.IsKeyDown(Keys.P, 0.5))
+ { // Toggle Pausing with TAB
+ if (isPaused) isPaused = false;
+ else isPaused = true;
+ }*/
+
+ Debug.WriteLine("---- ABOUT TO CHECK FOR IF TAB PRESSED ----");
+ bool menuCodeExecuted = false;
+ if (isPaused && inMenu)
+ {
+ menu.HandleInput(inputHandler);
+
+ // TODO: handle states
+ // ....
+ if (menu.outValue == 0) {
+ isPaused = inMenu = false;
+ menu.outValue = 328;
+ }
+ else if (menu.outValue == 3) // C# Language
+ { keywords = csharpKeywords; }
+ else if (menu.outValue == 4) // Assembly
+ { keywords = assemblyKeywords; }
+ else if (menu.outValue == 5)
+ { keywords = cppKeywords; }
+ else if (menu.outValue == 6) // BLACK
+ { isShill = usesBackgroundImage = false; }
+ else if (menu.outValue == 7) // CODE
+ { usesBackgroundImage = true; isShill = false; }
+ else if (menu.outValue == 8) // SHILL
+ { usesBackgroundImage = isShill = true; }
+
+
+ else if (false) { } // TODO: add
+
+
+ if (inputHandler.OnKeyPress(Keys.Tab)) isPaused = inMenu = false;
+
+ menuCodeExecuted = true;
+ }
+
+ if (inputHandler.OnKeyPress(Keys.Tab) && menuCodeExecuted == false)
+ {
+ Debug.WriteLine("NOW IN MENU");
+ isPaused = true;
+ inMenu = true;
+ }
+
+ // If In Menu
+
+
+ if (!isPaused)
+ {
+ if (inputHandler.IsKeyDown(Keys.W) || inputHandler.IsKeyDown(Keys.Up))
+ mainchara.GoUp();
+ else if (inputHandler.IsKeyDown(Keys.S) || inputHandler.IsKeyDown(Keys.Down))
+ mainchara.GoDown();
+ else if (inputHandler.IsKeyDown(Keys.D) || inputHandler.IsKeyDown(Keys.Right))
+ mainchara.GoRight();
+ else if (inputHandler.IsKeyDown(Keys.A) || inputHandler.IsKeyDown(Keys.Left))
+ mainchara.GoLeft();
+ if (inputHandler.IsKeyDown(Keys.Enter))
+ mainchara.Fire(ref bullets);
+ }
+
+ // Update Enemys and Bullets, e.g. deleting them where necessary
+ /*List<Enemy> toBeRemoved = new List<Enemy>();
+ foreach (Enemy e in enemies)
+ {
+ e.Update(ref bullets);
+ if (e.IsDestroyed) toBeRemoved.Add(e);
+ }
+ enemies.RemoveAll(e => toBeRemoved.Contains(e));*/
+ if (!isPaused)
+ {
+ List<Bullet> bulletsToBeRemoved = new List<Bullet>();
+ foreach (Bullet b in bullets)
+ {
+ b.Move();
+ if (b.IsDestroyed) bulletsToBeRemoved.Add(b);
+ }
+ bullets.RemoveAll(b => bulletsToBeRemoved.Contains(b));
+
+ // Handling Collisions
+ /* If the Word Enemys collide with the bullet, they are destroyed.
+ * If the Word Enemys or their Bullets collide with the player, a life is lost.
+ * */
+ collisionTimer.StartTime();
+
+ foreach (Bullet bullet in bullets)
+ {
+ if (bullet.isPlayersBullet)
+ {
+ foreach (Enemy enemy in enemies)
+ {
+ if (IsCollision(enemy.Borders, bullet.position))
+ {
+ enemy.IsDestroyed = true;
+ bullet.IsDestroyed = true;
+ score += enemy.points;
+ }
+ }
+ }
+ else
+ {
+ if (IsCollision(mainchara.Borders, bullet.position))
+ {
+ if (DateTime.Now - lifeLostTime > TimeSpan.FromSeconds(AfterLifeLostImmunityTime))
+ {
+ Debug.WriteLine("Player loses life!");
+ lives--;
+ lifeLost = true;
+ lifeLostTime = DateTime.Now;
+ isPaused = true;
+ mainchara.topleft.X = -10000; // Just to prevent loss of lives
+ mainchara.topleft.Y = -10000;
+ break;
+ }
+ else { } // Do nothing if still in regeneratory period
+
+ }
+ }
+ }
+ // Remove The
+ List<Enemy> tbr = new List<Enemy>();
+ foreach (Enemy e in enemies)
+ {
+ e.Update(ref bullets);
+ if (e.IsDestroyed) tbr.Add(e);
+ }
+ enemies.RemoveAll(e => tbr.Contains(e));
+
+ collisionTimer.EndTime();
+ Debug.WriteLine($"Collision Detection -> Time This Run {collisionTimer.GetLastDuration()}");
+ Debug.WriteLine($"Collision Detection -> Average Time {collisionTimer.GetAverageDuration()}");
+ }
+
+ if (isPaused && lifeLost)
+ {
+ if (DateTime.Now - lifeLostTime > TimeSpan.FromSeconds(LifeLostScreenDuration))
+ {
+ isPaused = lifeLost = false;
+ mainchara.topleft = MainCharacterStartingPosition;
+ }
+ }
+
+ base.Update(gameTime);
+ }
+
+ /// <summary>
+ /// This is called when the game should draw itself.
+ /// </summary>
+ /// <param name="gameTime">Provides a snapshot of timing values.</param>
+ protected override void Draw(GameTime gameTime)
+ {
+ GraphicsDevice.Clear(Color.Black);
+
+
+ spriteBatch.Begin();
+
+ if (usesBackgroundImage && !isPaused)
+ {
+ if (isShill)
+ spriteBatch.Draw(shillBackgroundImage, new Vector2(0, 0), Color.White);
+ else spriteBatch.Draw(codeBackgroundImage, new Vector2(0, 0), Color.White);
+ }
+
+
+
+ Debug.WriteLine("In Draw() -- spriteBatch begun");
+ Debug.WriteLine($"In Draw() -> enemies.Count = {enemies.Count}");
+ Debug.WriteLine($"In Draw() -> bullets.Count = {bullets.Count}");
+ Debug.WriteLine($"In Draw() -> player coords = ({mainchara.Borders[0].X}, {mainchara.Borders[0].Y})");
+ Debug.WriteLine("Enemy coordinates as follows: ");
+ foreach (Enemy enemy in enemies)
+ {
+ Debug.WriteLine($"\t{enemy.position}\t{enemy.direction}");
+ }
+
+ if (inMenu && isPaused) menu.Draw(spriteBatch, isShill);
+
+
+ // TODO: Add your drawing code here
+ if (lives == 0) // if game over
+ {
+ spriteBatch.DrawString(Consolas12SF, "GAME OVER!", new Vector2(250, 200), Color.White);
+ spriteBatch.DrawString(Consolas12SF, $"Points: {score}", new Vector2(250, 220), Color.Red);
+ spriteBatch.DrawString(Consolas12SF, $"Level: {level}", new Vector2(250, 240), Color.Red);
+
+ isPaused = true; // Otherwise score count can change
+ }
+ else
+ {
+ if (isPaused && !lifeLost)
+ {
+ Debug.WriteLine("In Draw -> isPaused");
+ spriteBatch.DrawString(Consolas12SF, "PAUSED", new Vector2(GraphicsAdapter.DefaultAdapter.CurrentDisplayMode.Height / 2,
+ GraphicsAdapter.DefaultAdapter.CurrentDisplayMode.Width / 2), Color.White);
+ }
+ else if (isPaused && lifeLost)
+ {
+ spriteBatch.DrawString(Consolas12SF, "YOU DIED", new Vector2(250, 250), Color.White);
+ spriteBatch.DrawString(Consolas12SF, $"{lives} lives left", new Vector2(250, 270), Color.White);
+ }
+ else
+ {
+ Debug.WriteLine("In Draw -> isNotPaused");
+ mainchara.Draw(spriteBatch);
+ foreach (Enemy enemy in enemies) enemy.Draw(spriteBatch);
+ foreach (Bullet bullet in bullets) bullet.Draw(spriteBatch);
+ }
+
+ spriteBatch.DrawString(Consolas12SF, $"Score: {score.ToString("X8")}", new Vector2(10, 10), Color.Red);
+ //spriteBatch.DrawString(Consolas12SF, $"n. Enemies {enemies.Count}", new Vector2(10, 50), Color.Red);
+ spriteBatch.DrawString(Consolas12SF, $"Level {Convert.ToString(level, 2).PadLeft(8, '0')}", new Vector2(10, 30), Color.Red);
+ }
+
+ spriteBatch.End();
+ base.Draw(gameTime);
+ }
+ }
+}
diff --git a/Icon.ico b/Icon.ico Binary files differnew file mode 100644 index 0000000..7d9dec1 --- /dev/null +++ b/Icon.ico diff --git a/InputHandler.cs b/InputHandler.cs new file mode 100644 index 0000000..1c74993 --- /dev/null +++ b/InputHandler.cs @@ -0,0 +1,97 @@ +using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Microsoft.Xna.Framework.Input;
+
+namespace Class_War
+{
+ class InputHandler
+ {
+ private KeyboardState _prevState;
+ public KeyboardState PreviousState { get => _prevState; set => _prevState = value; }
+
+ private KeyboardState _currentState;
+ public KeyboardState CurrentState { get => _currentState; set => _currentState = value; }
+
+ public void ReadInput ()
+ {
+ PreviousState = CurrentState;
+ CurrentState = Keyboard.GetState();
+ }
+
+ public bool IsKeyDown (Keys key)
+ {
+ if (CurrentState[key] == KeyState.Down) return true;
+ else return false;
+ }
+
+
+ private DateTime _isKeyDownLastCheck = DateTime.Now;
+ public DateTime KeyDownLastCheck
+ {
+ get { return _isKeyDownLastCheck; }
+ private set { _isKeyDownLastCheck = DateTime.Now; }
+ }
+
+
+
+ /// <summary>
+ /// Checks if a key is down, and will return false if the last keypress was earlier than
+ /// the timegap parameter. Keep changeKeyDownLastCheckIfFalse as false,
+ /// otherwise calling this function will interrupt the checking process.
+ /// </summary>
+ /// <param name="key"></param>
+ /// <param name="timegap"></param>
+ /// <param name="changeKeyDownLastCheckIfFalse"></param>
+ /// <returns></returns>
+ public bool IsKeyDown (Keys key, double timegap, bool changeKeyDownLastCheckIfFalse = false)
+ {
+ // Takes a DateTime, will return false if the DateTime is not after the last check.
+ // If enough time has passed, it will perform the check and return either true or false.
+ // Will not change KeyDownLastCheck unless true returned, except if changeKeyDownLastCheckIfFalse is true.
+
+ if (!((DateTime.Now - KeyDownLastCheck).TotalSeconds > timegap))
+ { // if not enough time has passed since last check
+ if (changeKeyDownLastCheckIfFalse) KeyDownLastCheck = DateTime.Now;
+ return false;
+ }
+ else // enough time has passed
+ {
+ if (CurrentState[key] == KeyState.Down)
+ { // Key has been pressed
+ KeyDownLastCheck = DateTime.Now;
+ return true;
+ }
+ else
+ { // Key has not been pressed
+ if (changeKeyDownLastCheckIfFalse)
+ {
+ KeyDownLastCheck = DateTime.Now;
+ return false;
+ }
+ else return false;
+ }
+ }
+
+
+
+
+
+ }
+
+ public bool OnKeyPress (Keys key)
+ {
+ if (CurrentState[key] == KeyState.Down && PreviousState[key] == KeyState.Up) return true;
+ else return false;
+ }
+
+ public bool OnKeyRelease (Keys key)
+ {
+ if (CurrentState[key] == KeyState.Up && PreviousState[key] == KeyState.Down) return true;
+ else return false;
+ }
+
+ }
+}
diff --git a/MainChara.cs b/MainChara.cs new file mode 100644 index 0000000..018f19a --- /dev/null +++ b/MainChara.cs @@ -0,0 +1,65 @@ +using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Microsoft.Xna.Framework.Graphics;
+using Microsoft.Xna.Framework.Content;
+using Microsoft.Xna.Framework;
+
+namespace Class_War
+{
+ class MainChara : Sprite
+ {
+ Texture2D image;
+ public Vector2 topleft;
+ ContentManager Content;
+ Vector2 size = new Vector2(50, 50);
+
+ public List<Vector2> Borders
+ {
+ get
+ {
+ Vector2 bottomright = new Vector2();
+ bottomright.X = (topleft.X + size.X);
+ bottomright.Y = (topleft.Y + size.Y);
+ return new List<Vector2>() { topleft, bottomright };
+ }
+ }
+
+ public void GoUp(int speed = 5)
+ {
+ topleft.Y -= speed;
+ }
+ public void GoDown(int speed = 5)
+ {
+ topleft.Y += speed;
+ }
+ public void GoLeft(int speed = 5)
+ {
+ topleft.X -= speed;
+ }
+ public void GoRight(int speed = 5)
+ {
+ topleft.X += speed;
+ }
+ public void Fire(ref List<Bullet> bullets, int speed = 5)
+ {
+ bullets.Add(new Bullet(Content, topleft, Direction.Up, speed, true));
+ }
+
+
+
+ public MainChara (ContentManager Content, string spriteImage, Vector2 position)
+ {
+ this.Content = Content;
+ image = Content.Load<Texture2D>(spriteImage);
+ this.topleft = position;
+ }
+
+ public void Draw(SpriteBatch sb)
+ {
+ sb.Draw(image, topleft, Color.White);
+ }
+ }
+}
@@ -0,0 +1,137 @@ +using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using Microsoft.Xna.Framework.Design;
+using Microsoft.Xna.Framework.Content;
+using Microsoft.Xna.Framework.Input;
+
+namespace Class_War
+{
+ class Menu
+ {
+ ContentManager Content;
+ SpriteFont font;
+ bool indented = false; // on the zeroth indentation level
+ int currentSelection = 0;
+ int indentedCurrSel = 0;
+ int maxSelection = 2;
+ public int outValue = 328;
+
+ public void HandleInput (InputHandler ih)
+ {
+ if (!indented)
+ {
+ if (ih.OnKeyRelease(Keys.W) || ih.OnKeyRelease(Keys.Up))
+ {
+ currentSelection--;
+ if (currentSelection < 0) currentSelection = maxSelection;
+ }
+ else if (ih.OnKeyRelease(Keys.S) || ih.OnKeyRelease(Keys.Down))
+ {
+ currentSelection++;
+ if (currentSelection > maxSelection) currentSelection = 0;
+ }
+ else if (ih.OnKeyRelease(Keys.Enter))
+ {
+ if (currentSelection == 2) outValue = 0;
+ else
+ {
+ indented = true;
+ }
+ }
+ }
+ else
+ {
+ if (ih.OnKeyRelease(Keys.W) || ih.OnKeyRelease(Keys.Up))
+ {
+ indentedCurrSel--;
+ if (indentedCurrSel < 0) indentedCurrSel = maxSelection;
+ }
+ else if (ih.OnKeyRelease(Keys.S) || ih.OnKeyRelease(Keys.Down))
+ {
+ indentedCurrSel++;
+ if (indentedCurrSel > maxSelection) indentedCurrSel = 0;
+ }
+ else if (ih.OnKeyRelease(Keys.Back))
+ {
+ indentedCurrSel = 0;
+ indented = false;
+ }
+ else if (ih.OnKeyRelease(Keys.Enter))
+ {
+ // Select options, by setting outValue to appropriate setting.
+ switch (currentSelection)
+ {
+ case 0 when (indentedCurrSel == 0): outValue = 3; break; // C#
+ case 0 when (indentedCurrSel == 1): outValue = 4; break; // Assembly
+ case 0 when (indentedCurrSel == 2): outValue = 5; break; // C++
+ case 1 when (indentedCurrSel == 0): outValue = 6; break; // Black
+ case 1 when (indentedCurrSel == 1): outValue = 7; break; // Code
+ case 1 when (indentedCurrSel == 2): outValue = 8; break; // Shill
+ }
+
+ indentedCurrSel = 0;
+ indented = false;
+ }
+ }
+ }
+
+ public Menu (ContentManager Content, string font)
+ {
+ this.Content = Content;
+ this.font = Content.Load<SpriteFont>(font);
+
+ }
+
+ public void Draw(SpriteBatch sb, bool isShill)
+ {
+ sb.DrawString(font, "Language", new Vector2(100, 100), Color.White);
+ sb.DrawString(font, "Background", new Vector2(100, 120), Color.White);
+ sb.DrawString(font, "Exit Menu", new Vector2(100, 140), Color.DarkRed);
+
+ if (indented && currentSelection == 0)
+ {
+ sb.DrawString(font, "C#", new Vector2(230, 100), Color.White);
+ sb.DrawString(font, "Assembly", new Vector2(230, 120), Color.White);
+ sb.DrawString(font, "C++", new Vector2(230, 140), Color.White);
+ }
+ else if (indented && currentSelection == 1)
+ {
+ sb.DrawString(font, "Black", new Vector2(230, 120), Color.White);
+ sb.DrawString(font, "Code", new Vector2(230, 140), Color.White);
+ sb.DrawString(font, "Sellout", new Vector2(230, 160), Color.White);
+ }
+
+ if (isShill) sb.DrawString(font, "Go subscribe to javidx9!!!", new Vector2(300, 300), Color.Green);
+
+ Vector2 position;
+ switch (currentSelection)
+ {
+ case 0 when (!indented): position = new Vector2(90, 100); break;
+ case 1 when (!indented): position = new Vector2(90, 120); break;
+ case 2 when (!indented): position = new Vector2(90, 140); break;
+
+
+ // Render Positions for when in LANGUAGE
+ case 0 when (indented && indentedCurrSel == 0): position = new Vector2(220, 100); break;
+ case 0 when (indented && indentedCurrSel == 1): position = new Vector2(220, 120); break;
+ case 0 when (indented && indentedCurrSel == 2): position = new Vector2(220, 140); break;
+
+ // Render Positions for when in BACKGROUND
+ case 1 when (indented && indentedCurrSel == 0): position = new Vector2(220, 120); break;
+ case 1 when (indented && indentedCurrSel == 1): position = new Vector2(220, 140); break;
+ case 1 when (indented && indentedCurrSel == 2): position = new Vector2(220, 160); break;
+
+ // Default: should never happen.
+ default: position = new Vector2(0, 0); break; // This should never happen.
+ };
+
+ sb.DrawString(font, ">", position, Color.White);
+ }
+ }
+}
diff --git a/Program.cs b/Program.cs new file mode 100644 index 0000000..379e7ef --- /dev/null +++ b/Program.cs @@ -0,0 +1,22 @@ +using System;
+
+namespace Class_War
+{
+#if WINDOWS || LINUX
+ /// <summary>
+ /// The main class.
+ /// </summary>
+ public static class Program
+ {
+ /// <summary>
+ /// The main entry point for the application.
+ /// </summary>
+ [STAThread]
+ static void Main()
+ {
+ using (var game = new Game1())
+ game.Run();
+ }
+ }
+#endif
+}
diff --git a/Sprite.cs b/Sprite.cs new file mode 100644 index 0000000..14e1d50 --- /dev/null +++ b/Sprite.cs @@ -0,0 +1,14 @@ +using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Microsoft.Xna.Framework.Graphics;
+
+namespace Class_War
+{
+ interface Sprite
+ {
+ void Draw(SpriteBatch sb);
+ }
+}
diff --git a/Timer.cs b/Timer.cs new file mode 100644 index 0000000..748e7b2 --- /dev/null +++ b/Timer.cs @@ -0,0 +1,47 @@ +using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Class_War
+{
+ class Timer
+ {
+ TimeSpan avgDuration;
+ DateTime t1;
+ DateTime t2;
+ bool isTiming = false;
+ bool firstTiming = true;
+ int numTimings = 0;
+
+ public void StartTime()
+ {
+ t1 = DateTime.Now;
+ isTiming = true;
+ }
+
+ public void EndTime()
+ {
+ t2 = DateTime.Now;
+ isTiming = false;
+ if (firstTiming) firstTiming = false;
+ numTimings++;
+ avgDuration.Add(t2 - t1);
+ }
+
+ public TimeSpan GetLastDuration()
+ {
+ if (!isTiming) return t2 - t1;
+ else throw new InvalidOperationException("Cannot call GetDuration when currently timing");
+ }
+
+ public TimeSpan GetAverageDuration()
+ {
+ if (numTimings == 0) throw new InvalidOperationException("No average duration where no timing has completed yet");
+ return TimeSpan.FromTicks(avgDuration.Ticks / numTimings);
+ }
+
+
+ }
+}
diff --git a/app.manifest b/app.manifest new file mode 100644 index 0000000..760ba86 --- /dev/null +++ b/app.manifest @@ -0,0 +1,42 @@ +<?xml version="1.0" encoding="utf-8"?> +<assembly manifestVersion="1.0" xmlns="urn:schemas-microsoft-com:asm.v1"> + <assemblyIdentity version="1.0.0.0" name="Class_War"/> + <trustInfo xmlns="urn:schemas-microsoft-com:asm.v2"> + <security> + <requestedPrivileges xmlns="urn:schemas-microsoft-com:asm.v3"> + <requestedExecutionLevel level="asInvoker" uiAccess="false" /> + </requestedPrivileges> + </security> + </trustInfo> + + <compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1"> + <application> + <!-- A list of the Windows versions that this application has been tested on and is + is designed to work with. Uncomment the appropriate elements and Windows will + automatically selected the most compatible environment. --> + + <!-- Windows Vista --> + <supportedOS Id="{e2011457-1546-43c5-a5fe-008deee3d3f0}" /> + + <!-- Windows 7 --> + <supportedOS Id="{35138b9a-5d96-4fbd-8e2d-a2440225f93a}" /> + + <!-- Windows 8 --> + <supportedOS Id="{4a2f28e3-53b9-4441-ba9c-d69d4a4a6e38}" /> + + <!-- Windows 8.1 --> + <supportedOS Id="{1f676c76-80e1-4239-95bb-83d0f6d0da78}" /> + + <!-- Windows 10 --> + <supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}" /> + + </application> + </compatibility> + + <application xmlns="urn:schemas-microsoft-com:asm.v3"> + <windowsSettings> + <dpiAware xmlns="http://schemas.microsoft.com/SMI/2005/WindowsSettings">true/pm</dpiAware> + </windowsSettings> + </application> + +</assembly> |