[RELEASED] - AoC - My Elements of War modifications



  • http://www.ElementsofWar.net/
    http://www.ModDB.com/Mods/Elements-of-War

    Source(Half-Life 2): A default single player mod
    World of WarCraft: Hotkeys and Macros
    Unreal Tournament 2004: Sky camera system and a number of levels

    Elements of War: 1337 Board: A hotkeys menu and config.cfg mod for ALL Valve games/mods. That includes Age of Chivalry(I don’t think it’ll show the hotkeys menu in AoC though, but you can manually look at it or use a different game/mod). I’d suggest just downloading EoW v12 for Source, as it includes the latest version of 1337 Board.



  • I don’t see myself ever making money through Valve, so, I’m pretty much wasting my time there.

    Not sure what I wanna do now. I was thinking about making the sky camera system for UDK, but I cannot get the GameType to show in the game… Once I figure that out, I might look into coding it.

    I’ve also considered dabbing with C# under Microsoft Visual Studio and making a really, really basic 2D game.



  • If you consider the C# route, Microsoft does have the XNA package which seems to be really nice.



  • I think I remembered why I didn’t go with C#, you had to make an X-BoX game to sell it and I didn’t wanna waste an insane amount of time trying to make achievements and whatever bs they made you do.

    Are you able to make profit off a “WindowZ” game or is it only X-BoX/WindowZ Phone? I mean they have GameZ for WindowZ now



  • ok, seems you have complete control over the WindowZ version. But if you want it on X-BoX / WindowZ Phone it’s $99 a year for like ten games on the service. Also, you don’t need to do achievements and stuff like that. Unless you wanna go from XBLIG to XBLAG

    Here’s some sloppy code // comments

    // /* *** *** ***                 *** *** *** */ //
    // /* *** *** *** Elements of War *** *** *** */ //
    // /* *** *** ***                 *** *** *** */ //
    
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using Microsoft.Xna.Framework;
    using Microsoft.Xna.Framework.Audio;
    using Microsoft.Xna.Framework.Content;
    using Microsoft.Xna.Framework.GamerServices;
    using Microsoft.Xna.Framework.Graphics;
    using Microsoft.Xna.Framework.Input;
    /*
    #region
    #if Windows_Phone
    // using Microsoft.Xna.Framework.Input.Touch;
    #elseif
    #endregion
    */
    using Microsoft.Xna.Framework.Media;
    
    namespace ElementsofWar
    {
        public class Game1 : Microsoft.Xna.Framework.Game
        {
            // Classes
            // Class_UnknowN class_UnknowN;
            // Class_Player class_Player;
            // Class_HUD class_HUD;
    
            // SignedInGamer gamer = Gamer.SignedInGamers[0];
            // string gamerTag = gamer.GamerTag;
            // GamerProfile profile = Gamer.GetProfile();
            // int gamerScore = GamerProfile.GamerScore;
            // Stream gamerPictureStream = profile.GamerPicture;
    
            // TimeSpan gameElapsed;
            // TimeSpan startScreenTime;
    
            // Graphics Engine // Video
            GraphicsDeviceManager graphics;
            SpriteBatch spriteBatch;
    
    /*
            // Viewport
            Viewport currentViewport;
                Viewport previousViewport;
                Viewport viewport;
                Viewport ViewPort1;
                Viewport Viewport2;
                Viewport Viewport3;
                Viewport Viewport4;
                Viewport Viewport5;
                Viewport Spectator;
    
                Viewport Player_Viewport;
                Viewport Player2_Viewport;
                Viewport Player3_Viewport;
                Viewport Player4_Viewport;
                Viewport Player5_Viewport;
    */
    
            Rectangle Viewport_Rect;
                Vector2 Viewport_Position = Vector2.Zero;
                Vector2 Viewport_Width = Vector2.Zero;
                Vector2 Viewport_Height = Vector2.Zero;
    
                Rectangle Screen_Rect;
                Vector2 Screen_Position = Vector2.Zero;
                int Screen_Width;
                int Screen_Height;
    
                // Viewport 2
                Rectangle Viewport2_Rect;
                Vector2 Viewport2_Position = Vector2.Zero;
                Vector2 Viewport2_Width = Vector2.Zero;
                Vector2 Viewport2_Height = Vector2.Zero;
    
                Rectangle Screen2_Rect;
                Vector2 Screen2_Position = Vector2.Zero;
                int Screen2_Width;
                int Screen2_Height;
    
                // Viewport 3
                Rectangle Viewport3_Rect;
                Vector2 Viewport3_Position = Vector2.Zero;
                Vector2 Viewport3_Width = Vector2.Zero;
                Vector2 Viewport3_Height = Vector2.Zero;
    
                Rectangle Screen3_Rect;
                Vector2 Screen3_Position = Vector2.Zero;
                int Screen3_Width;
                int Screen3_Height;
    
                // Viewport 4
                Rectangle Viewport4_Rect;
                Vector2 Viewport4_Position = Vector2.Zero;
                Vector2 Viewport4_Width = Vector2.Zero;
                Vector2 Viewport4_Height = Vector2.Zero;
    
                Rectangle Screen4_Rect;
                Vector2 Screen4_Position = Vector2.Zero;
                int Screen4_Width;
                int Screen4_Height;
    
            // Background
            Texture2D Background;
                Texture2D Foreground;
    
            // Console
            Texture2D Console;
                Vector2 Console_Position = Vector2.Zero;
                Vector2 Console_Width = Vector2.Zero;
                Vector2 Console_Height = Vector2.Zero;
    
        // TouchCollection touchState;
        // AccelerometerState accelerometerState;
    
            // Keyboard
            KeyboardState currentKeyboardState;
                KeyboardState previousKeyboardState;
                KeyboardState keyboardState;
    
            // GamePad
            // GamePadType gamePadType;
                // GamePadType gamePadType2;
                // GamePadType gamePadType3;
                // GamePadType gamePadType4;
            GamePadState currentGamePadState;
                // GamePadState currentGamePadState2;
                // GamePadState currentGamePadState3;
                // GamePadState currentGamePadState4;
            GamePadState previousGamePadState;
                // GamePadState previousGamePadState2;
                // GamePadState previousGamePadState3;
                // GamePadState previousGamePadState4;
            GamePadState gamePadState;
                // GamePadState gamePadState2;
                // GamePadState gamePadState3;
                // GamePadState gamePadState4;
    
            // GamePadState gamePadState = GamePad.GetState(PlayerIndex.One);
                // GamePadState gamePadState2 = GamePad.GetState(PlayerIndex.Two);
                // GamePadState gamePadState3 = GamePad.GetState(PlayerIndex.Three);
                // GamePadState gamePadState4 = GamePad.GetState(PlayerIndex.Four);
    
            // Mouse
            MouseState currentMouseState;
                MouseState previousMouseState;
                MouseState mouseState;
    
                Texture2D Mouse_Texture;
                Rectangle Mouse_Rect;
                Vector2 Mouse_Position = Vector2.Zero;
                int Mouse_Position_X;
                int Mouse_Position_Y;
                Vector2 Mouse_Width = Vector2.Zero;
                Vector2 Mouse_Height = Vector2.Zero;
    
                bool Mouse_Button_Left_Clicked;
                bool Mouse_Button_Right_Clicked;
    
                Texture2D Mouse2_Texture;
                Rectangle Mouse2_Rect;
                Vector2 Mouse2_Position = Vector2.Zero;
                int Mouse2_Position_X;
                int Mouse2_Position_Y;
                Vector2 Mouse2_Width = Vector2.Zero;
                Vector2 Mouse2_Height = Vector2.Zero;
    
                bool Mouse2_Button_Left_Clicked;
                bool Mouse2_Button_Right_Clicked;
    
                Texture2D Mouse3_Texture;
                Rectangle Mouse3_Rect;
                Vector2 Mouse3_Position = Vector2.Zero;
                int Mouse3_Position_X;
                int Mouse3_Position_Y;
                Vector2 Mouse3_Width = Vector2.Zero;
                Vector2 Mouse3_Height = Vector2.Zero;
    
                bool Mouse3_Button_Left_Clicked;
                bool Mouse3_Button_Right_Clicked;
    
                Texture2D Mouse4_Texture;
                Rectangle Mouse4_Rect;
                Vector2 Mouse4_Position = Vector2.Zero;
                int Mouse4_Position_X;
                int Mouse4_Position_Y;
                Vector2 Mouse4_Width = Vector2.Zero;
                Vector2 Mouse4_Height = Vector2.Zero;
    
                bool Mouse4_Button_Left_Clicked;
                bool Mouse4_Button_Right_Clicked;
    
            // Animations
    //            Animation Anim_Player_Idle;
    //            Animation Anim_Player_Run;
    //            Animation Anim_Player_Jump;
    //            Animation Anim_Player_Die;
    
            // Specating and Teams, AI
            bool Spectator_Limit;
                bool Team_1_Limit;
                bool Team_2_Limi;
                bool Team_1_Limit_AI;
                bool Team_2_Limit_AI;
                bool Team_1_Amount;
                bool Team_2_Amount;
                bool Team_1_Amount_AI;
                bool Team_2_Amount_AI;
                bool Team_1_Level;
                bool Team_2_Level;
                bool Team1_Level_AI;
                bool Team2_Level_AI;
    
            // Player
            Texture2D Player_Texture;
                // Rectangle Player_Position;
                Vector2 Player_Position = Vector2.Zero;
                int Player_Position_X;
                int Player_Position_Y;
                Vector2 Player_Width = Vector2.Zero;
                Vector2 Player_Height = Vector2.Zero;
    
                Vector2 Player_Rotation = Vector2.Zero;
                int Player_Rotation_0;
                int Player_Rotation_360;
                int Player_Rotation_INT;
                float Player_Rotation_FLOAT;
                Vector2 Player_Origin = Vector2.Zero;
    
            // Player 2
            Texture2D Player2_Texture;
                // Rectangle Player2_Position;
                Vector2 Player2_Position = Vector2.Zero;
                int Player2_Position_X;
                int Player2_Position_Y;
                Vector2 Player2_Width = Vector2.Zero;
                Vector2 Player2_Height = Vector2.Zero;
    
                Vector2 Player2_Rotation = Vector2.Zero;
                int Player2_Rotation_0;
                int Player2_Rotation_360;
                int Player2_Rotation_INT;
    
            // Player 3
            Texture2D Player3_Texture;
                // Rectangle Player3_Position;
                Vector2 Player3_Position = Vector2.Zero;
                int Player3_Position_X;
                int Player3_Position_Y;
                Vector2 Player3_Width = Vector2.Zero;
                Vector2 Player3_Height = Vector2.Zero;
    
                Vector2 Player3_Rotation = Vector2.Zero;
                int Player3_Rotation_0;
                int Player3_Rotation_360;
                int Player3_Rotation_INT;
    
            // Player4
            Texture2D Player4_Texture;
                // Rectangle Player4_Position;
                Vector2 Player4_Position = Vector2.Zero;
                int Player4_Position_X;
                int Player4_Position_Y;
                Vector2 Player4_Width = Vector2.Zero;
                Vector2 Player4_Height = Vector2.Zero;
    
                Vector2 Player4_Rotation = Vector2.Zero;
                int Player4_Rotation_0;
                int Player4_Rotation_360;
                int Player4_Rotation_INT;
                float Player4_Rotation_FLOAT;
                Vector2 Player4_Origin = Vector2.Zero;
    
    /*            bool Player_Anim_Attack;
                    bool Player_Anim_Attack2;
                    bool Player_Anim_Block;
                    bool Player_Anim_Forward;
                    bool Player_Anim_Back;
                    bool Player_Anim_Left;
                    bool Player_Anim_Right;
                    bool Player_Anim_Jump;
                    bool Player_Anim_Duck;
    */
    
            // Weapon
            bool Fireball_Enabled;
                Texture2D Fireball_Texture;
                // Rectangle Fireball_Position;
                Vector2 Fireball_Position = Vector2.Zero;
                int Fireball_Position_X;
                int Fireball_Position_Y;
                Vector2 Fireball_Width = Vector2.Zero;
                Vector2 Fireball_Height = Vector2.Zero;
    
                Vector2 Fireball_Rotation = Vector2.Zero;
                int Fireball_Rotation_0;
                int Fireball_Rotation_360;
                int Fireball_Rotation_INT;
                float Fireball_Rotation_FLOAT;
                Vector2 Fireball_Origin = Vector2.Zero;
    
            bool Player_Spectating;
                bool Player_Human_or_AI;
                bool Player_Sex;
                bool Player_Team;
                bool Player_Alive;
                int Player_Health;
                int Player_Mana;
                bool Player_Stamina;
                bool Player_Breath;
                bool Player_Armor_Head;
                bool Player_Armor_Body;
                bool Player_Level;
                bool Player_Kills;
                bool Player_Deaths;
                int Player_Score;
    
                bool Player_Weapon_Current;
                bool Player_Weapon_Last;
                bool Player_Weapon_Next;
    
            // Physics
            bool sv_Phy_Speed_Max;
                bool sv_Phy_Speed_Min;
                int sv_Phy_Speed_Default;
                bool sv_Phy_Speed_Forward;
                bool sv_Phy_Speed_Backward;
                bool sv_Phy_Speed_Strafe;
                bool sv_Phy_Speed_ForwardStrafe;
                bool sv_Phy_Speed_BackStrafe;
    
                bool sv_Phy_Walking_Enabled;
                bool sv_Phy_Running_Enabled;
    
                bool sv_Phy_Gravity;
                bool sv_Phy_Jumping_Enabled;
                bool sv_Phy_Ducking_Enabled;
                bool sv_Phy_Duck_Speed;
                bool sv_Phy_Jump_Height;
                bool sv_Phy_MultiJumps;
                bool sv_Phy_Dodging;
    
                bool sv_Phy_AirAccelRate;
                bool sv_Phy_Air_Strafe;
                bool sv_Phy_Air_Curve;
                bool sv_Phy_Air_Movement;
    
            // Camera
            bool Camera_ThirdPerson;
                bool Camera_Distance_Min;
                bool Camera_Distance_Max;
                bool Camera_Distance;
                bool Camera_Pitch_Min;
                bool Camera_Pitch_Max;
                bool Camera_Pitch;
                bool Camera_Yaw_Min;
                bool Camera_Yaw_Max;
                bool Camera_Yaw;
                bool Camera_Side_Min;
                bool Camera_Side_Max;
                bool Camera_Side;
                bool Camera_Sky_Min;
                bool Camera_Sky_Max;
                bool Camera_Sky;
    
                // Make default hotkeys here?
    
                // Models
                // Model Player_Model = NuLL;
                // Model Player_Model;
    
                // Sounds
                SoundEffect Sound_NuLL;
    
                SoundEffect Sound_Fireball;
                SoundEffect Sound_Player_Walking;
                SoundEffect Sound_Male_Dead;
    
                SoundEffect Sound_Mouse_Left_Clicked;
                SoundEffect Sound_Mouse_Right_Clicked;
    
                SoundEffect Sound_Console;
                SoundEffect Sound_MainMenu;
                SoundEffect Sound_Win;
                SoundEffect Sound_Lose;
    
                //           SoundEffect Sound_Player_Killed;
                //           SoundEffect Sound_Player_Died;
    
            public Game1()
            {
                graphics = new GraphicsDeviceManager(this);
                Content.RootDirectory = "Content";
            #if WINDOWS
                    // IsFixedTimeStep = false;
            #endif
            #if XBOX
            #endif
            #if WINDOWS_PHONE
                    graphics.IsFullScreen = true;
    
                    // Frame rate is 30 fps by default for Windows Phone.
                    TargetElapsedTime = TimeSpan.FromTicks(333333);
    
                    // Extend battery life under lock.
                    // InactiveSleepTime = TimeSpan.FromSeconds(1);
            #endif
            }
    
            /// <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()
            {
                Window.Title = "Elements of War Window Title";
                graphics.PreferredBackBufferWidth = 800;
                graphics.PreferredBackBufferHeight = 600;
                graphics.IsFullScreen = true;
                graphics.ApplyChanges();
    
                // Initialize classes
                // Class_UnknowN class_UnknowN;
                // Class_Player class_Player;
                // Class_HUD class_HUD;
    
                // Add code above
                base.Initialize();
            }
    
            protected override void LoadContent()
            {
                // Initialize classes
                // class_UnknowN = new Class_UnknowN();
                // Class_Player class_Player;
                // Class_HUD class_HUD;
    
                Screen_Width = graphics.GraphicsDevice.PresentationParameters.BackBufferWidth;
                Screen_Height = graphics.GraphicsDevice.PresentationParameters.BackBufferHeight;
    
                Viewport_Rect = new Rectangle(0, 0, graphics.GraphicsDevice.Viewport.Width, 
                    graphics.GraphicsDevice.Viewport.Height);
    
                Mouse_Rect = new Rectangle(0, 0, 16, 16);
                Mouse.SetPosition(0, 0);
                //Mouse.SetPosition(Mouse_X, Mouse_Y);
    
                // Mouse2_Position = 0;
                Mouse2_Position.X = 0;
                Mouse2_Position.Y = 0;
                Mouse3_Position.X = 0;
                Mouse3_Position.Y = 0;
                Mouse4_Position.X = 0;
                Mouse4_Position.Y = 0;
    
                // Create a new SpriteBatch, which can be used to draw textures.
                spriteBatch = new SpriteBatch(GraphicsDevice);
    
                Background = Content.Load<texture2d>("Background");
                Foreground = Content.Load<texture2d>("Foreground");
    
                Console = Content.Load<texture2d>("Console");
    
                Mouse_Texture = Content.Load<texture2d>("Mouse_Texture");
                Mouse2_Texture = Content.Load<texture2d>("Mouse2_Texture");
                Mouse3_Texture = Content.Load<texture2d>("Mouse3_Texture");
                Mouse4_Texture = Content.Load<texture2d>("Mouse4_Texture");
    
                Player_Texture = Content.Load<texture2d>("Player_Texture");
                Player2_Texture = Content.Load<texture2d>("Player2_Texture");
                Player3_Texture = Content.Load<texture2d>("Player3_Texture");
                Player4_Texture = Content.Load<texture2d>("Player4_Texture");
    
    //            Anim_Player_Idle = new Animation(Content.Load<texture2d>("Sprites/Player/Idle"), 0.1f, true);
    //            Anim_Player_Run = new Animation(Content.Load<texture2d>("Sprites/Player/Run"), 0.1f, true);
    //            Anim_Player_Jump = new Animation(Content.Load<texture2d>("Sprites/Player/Jump"), 0.1f, false);
    //            Anim_Player_Die = new Animation(Content.Load<texture2d>("Sprites/Player/Die"), 0.1f, false);
    
               //////// spriteSheetforward = Content.Load<texture2d>(Player_Running_Foward);
               //////// spriteSheetbackward = Content.Load<texture2d>(Player_Running_Back);
    
                Player_Score = 0;
                Player_Health = 100;
                Player_Mana = 100;
    
                Player_Position.X = 0;
                Player_Position.Y = 0;
    
                Player_Position_X = 0;
                Player_Position_Y = 0;
                Player2_Position_X = 0;
                Player2_Position_Y = 0;
    
                Player_Rotation_0 = 0;
                Player_Rotation_360 = 360;
                Player_Rotation_INT = 0;
    
                Player_Rotation_FLOAT = 1.0f;
    
                Player_Origin.X = 0;
                Player_Origin.Y = 0;
    
                Fireball_Enabled = false;
                Fireball_Position_X = Player_Position_X + 0;
                Fireball_Position_Y = Player_Position_Y + 0;
    
                // Models
                // Player_Model = Content.Load<model>("Player_Model");
    
                // Sounds         
                Sound_NuLL = Content.Load<soundeffect>("Sound/NuLL");
    
                Sound_Fireball = Content.Load<soundeffect>("Sound_Fireball");
    //            Sound_Player_Jump = Content.Load<soundeffect>("Sound/NuLL");
                // Sound_Player_Fall = Content.Load<soundeffect>("Sound/PlayerFall");
            }
            protected override void UnloadContent()
            {
    
            }
    
            /// <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.
            protected override void Update(GameTime gameTime)
    //            KeyboardState keyboardState,
    //            GamePadState gamePadState,
    //            TouchCollection touchState,
    //            AccelerometerState accelState,
    //            DisplayOrientation orientation)
            {
                // float time = (float)gameTime.TotalGameTime.TotalSeconds;
                // float ElapsedTimeFloat = (float)gameTime.ElapsedGameTime.TotalSeconds;
    
                // Player
                Player_Input_Device();
                Player2_Input_Device();
                Player3_Input_Device();
                Player4_Input_Device();
    
                // Player_Collision();
    
                // Add code above
                base.Update(gameTime);
            }
    
            protected void Player_Input_Device()
            {
                previousMouseState = currentMouseState;
                currentMouseState = Mouse.GetState();
                MouseState mouseState = Mouse.GetState();
                // // //            Mouse.GetState();
    
                previousKeyboardState = currentKeyboardState;
                currentKeyboardState = Keyboard.GetState();
                KeyboardState keyboardState = Keyboard.GetState();
    
                previousGamePadState = currentGamePadState;
                    // previousGamePadState2 = currentGamePadState2;
                    // previousGamePadState3 = currentGamePadState3;
                    // previousGamePadState4 = currentGamePadState4;
                currentGamePadState = GamePad.GetState(PlayerIndex.One);
                    // currentGamePadState2 = GamePad.GetState(PlayerIndex.Two);
                    // currentGamePadState3 = GamePad.GetState(PlayerIndex.Three);
                    // currentGamePadState4 = GamePad.GetState(PlayerIndex.Four);
                GamePadState gamePadState = GamePad.GetState(PlayerIndex.One);
                    // GamePadState gamePadState2 = GamePad.GetState(PlayerIndex.Two);
                    // GamePadState gamePadState3 = GamePad.GetState(PlayerIndex.Three);
                    // GamePadState gamePadState4 = GamePad.GetState(PlayerIndex.Four);
    
                if
                (
                    keyboardState.IsKeyDown(Keys.Escape)
                    ||
                    GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed
                    ||
                    GamePad.GetState(PlayerIndex.Two).Buttons.Back == ButtonState.Pressed
                    ||
                    GamePad.GetState(PlayerIndex.Three).Buttons.Back == ButtonState.Pressed
                    ||
                    GamePad.GetState(PlayerIndex.Four).Buttons.Back == ButtonState.Pressed
                    // ||
                    // mouseState.LeftButton == ButtonState.Pressed
                )
                {
                    this.Exit();
                }
    
                Mouse_Position.X = mouseState.X;
                Mouse_Position.Y = mouseState.Y;
    
                // Mouse2_Position.X = mouseState.X;
                // Mouse2_Position.Y = mouseState.Y;
    
                // Mouse3_Position.X = mouseState.X;
                // Mouse3_Position.Y = mouseState.Y;
    
                // Mouse4_Position.X = mouseState.X;
                // Mouse4_Position.Y = mouseState.Y;
    
                if (mouseState.LeftButton == ButtonState.Pressed)
                {
                    Mouse_Button_Left_Clicked = true;
                    Sound_Fireball.Play();
                }
                else if (mouseState.LeftButton == ButtonState.Released)
                {
                }
    
                if (mouseState.RightButton == ButtonState.Pressed)
                {
                    Mouse_Button_Right_Clicked = true;
                }
    
                else if (mouseState.RightButton == ButtonState.Released)
                {
                }
    
                if (currentKeyboardState.IsKeyDown(Keys.LeftAlt))
                {
                    Sound_NuLL.Play();
                }
    
                if (currentKeyboardState.IsKeyDown(Keys.J))
                {
    
                    graphics.PreferredBackBufferWidth = 1024;
                    graphics.PreferredBackBufferHeight = 768;
                    graphics.IsFullScreen = true;
                    graphics.ApplyChanges();
    
                    // System.Console.WriteLine("We're in debug mode");
    
                    // Sound_Fireball.Play();
                }
    //            if (currentKeyboardState.IsKeyUp(Keys.J))
    //            {
    //                Fireball_Enabled = false;
    //            }
    
                // if (currentKeyboardState.IsKeyDown(Keys.K))
                // {
                    // Mouse_Position.X = += 4;
                // }
    
                if (currentKeyboardState.IsKeyDown(Keys.A))
                {
                    Player_Position.Y += 4;
                    if (Player_Position.Y <= 0)
                    {
                        Player_Position.Y = 0;
                    }
                    if (Player_Position.Y >= graphics.GraphicsDevice.Viewport.Height - 64)
                    {
                        Player_Position.Y = graphics.GraphicsDevice.Viewport.Height - 64;
                    }
                    Player_Position_Y += 4;
                }
                if (currentKeyboardState.IsKeyDown(Keys.S))
                {
                    Player_Position.Y -= 4;
                    if (Player_Position.Y <= 0)
                    {
                        Player_Position.Y = 0;
                    }
                    if (Player_Position.Y >= graphics.GraphicsDevice.Viewport.Height - 64)
                    {
                        Player_Position.Y = graphics.GraphicsDevice.Viewport.Width - 64;
                    }
                    Player_Position_Y -= 4;
                }
                if (currentKeyboardState.IsKeyDown(Keys.D))
                {
                    Player_Position.X -= 4;
                    if (Player_Position.X <= 0)
                    {
                        Player_Position.X = 0;
                    }
                    if (Player_Position.X >= graphics.GraphicsDevice.Viewport.Width - 64)
                    {
                        Player_Position.X = graphics.GraphicsDevice.Viewport.Width - 64;
                    }
                    Player_Position_X -= 4;
                }
                if (currentKeyboardState.IsKeyDown(Keys.F))
                {
                    Player_Position.X += 4;
                    if (Player_Position.X <= 0)
                    {
                        Player_Position.X = 0;
                    }
                    if (Player_Position.X >= graphics.GraphicsDevice.Viewport.Width - 64)
                    {
                        Player_Position.X = graphics.GraphicsDevice.Viewport.Width - 64;
                    }
                    Player_Position_X += 4;
                }
    
                if (currentKeyboardState.IsKeyDown(Keys.Down) ||
                    currentGamePadState.DPad.Down == ButtonState.Pressed)
                {
                    Player_Position.Y += 4;
                    if (Player_Position.Y <= 0)
                    {
                        Player_Position.Y = 0;
                    }
                    if (Player_Position.Y >= graphics.GraphicsDevice.Viewport.Height - 64)
                    {
                        Player_Position.Y = graphics.GraphicsDevice.Viewport.Height - 64;
                    }
                    Player_Position_Y += 4;
                }
    
                if (currentKeyboardState.IsKeyDown(Keys.Up) ||
                    currentGamePadState.DPad.Up == ButtonState.Pressed)
                {
                    Player_Position.Y -= 4;
                    if (Player_Position.Y <= 0)
                    {
                        Player_Position.Y = 0;
                    }
                    if (Player_Position.Y >= graphics.GraphicsDevice.Viewport.Height - 64)
                    {
                        Player_Position.Y = graphics.GraphicsDevice.Viewport.Height - 64;
                    }
                    Player_Position_Y -= 4;
                }
    
                if (currentKeyboardState.IsKeyDown(Keys.Left) ||
                currentGamePadState.DPad.Left == ButtonState.Pressed)
                {
                    Player_Position.X -= 4;
                    if (Player_Position.X <= 0)
                    {
                        Player_Position.X = 0;
                    }
                    if (Player_Position.X >= graphics.GraphicsDevice.Viewport.Width - 64)
                    {
                        Player_Position.X = graphics.GraphicsDevice.Viewport.Width - 64;
                    }
                    Player_Position_X -= 4;
                }
    
                if (currentKeyboardState.IsKeyDown(Keys.Right) ||
                currentGamePadState.DPad.Right == ButtonState.Pressed)
                {
                    Player_Position.X += 4;
                    if (Player_Position.X <= 0)
                    {
                        Player_Position.X = 0;
                    }
                    if (Player_Position.X >= graphics.GraphicsDevice.Viewport.Width - 64)
                    {
                        Player_Position.X = graphics.GraphicsDevice.Viewport.Width - 64;
                    }
                    Player_Position_X += 4;
                }
            }
    
            protected void Player2_Input_Device()
            {
            }
            protected void Player3_Input_Device()
            {
            }
            protected void Player4_Input_Device()
            {
            }
    
            /// <summary>/// This is called when the game should draw itself.
            ///</summary> 
            /// <param name="gameTime">Provides a snapshot of timing values.
            protected override void Draw(GameTime gameTime)
            {
                // Background
                GraphicsDevice.Clear(Color.Black);
    
                spriteBatch.Begin();
                spriteBatch.Draw(Background, Viewport_Rect, Color.White);
                spriteBatch.End();
    
    /*
                spriteBatch.Begin();
                spriteBatch.Draw(Background, Background_Position, Color.White);
                spriteBatch.End();
    
                spriteBatch.Begin();
                spriteBatch.Draw(Background2, Background2_Position, Color.White);
                spriteBatch.End();
    
                spriteBatch.Begin();
                spriteBatch.Draw(Background3, Background3_Position, Color.White);
                spriteBatch.End();
    
                spriteBatch.Begin();
                spriteBatch.Draw(Background4, Background4_Position, Color.White);
                spriteBatch.End();
    */
                spriteBatch.Begin(SpriteSortMode.BackToFront, BlendState.AlphaBlend);
                spriteBatch.Draw(Mouse_Texture, Mouse_Position, Color.White);
                spriteBatch.End();
    /*
                spriteBatch.Begin(SpriteSortMode.BackToFront, BlendState.AlphaBlend);
                spriteBatch.Draw(Mouse2_Texture, Mouse2_Position, Color.White);
                spriteBatch.End();
    
                spriteBatch.Begin(SpriteSortMode.BackToFront, BlendState.AlphaBlend);
                spriteBatch.Draw(Mouse3_Texture, Mouse3_Position, Color.White);
                spriteBatch.End();
    
                spriteBatch.Begin(SpriteSortMode.BackToFront, BlendState.AlphaBlend);
                spriteBatch.Draw(Mouse4_Texture, Mouse4_Position, Color.White);
                spriteBatch.End();
    */
    
    //            spriteBatch.Begin();
    //            Draw_Scenery();
    //            Draw_Player();
    
    //            Draw_HUD();
    //            Draw_Team();
    //            Draw_Enemy();
    //            spriteBatch.End();
    
                // Player
                spriteBatch.Begin(SpriteSortMode.BackToFront, BlendState.AlphaBlend);
                spriteBatch.Draw(Player_Texture, Player_Position, Color.White);
                spriteBatch.End();
    
    //            spriteBatch.Begin(SpriteSortMode.BackToFront, BlendState.AlphaBlend);
    //            spriteBatch.Draw(Player_Texture, Player_Position, Viewport_Rect, Color.White, Player_Rotation_FLOAT, Player_Origin, 1.0f, SpriteEffects.None, 1);
    //            spriteBatch.End();
    
                // Player 2
                // spriteBatch.Begin(SpriteSortMode.BackToFront, BlendState.AlphaBlend);
                // spriteBatch.Draw(Player2_Texture, Player2_Position, Color.White);
                // spriteBatch.End();
    
                // Player 3
                // spriteBatch.Begin(SpriteSortMode.BackToFront, BlendState.AlphaBlend);
                // spriteBatch.Draw(Player3_Texture, Player3_Position, Color.White);
                // spriteBatch.End();
    
                // Player 4
                // spriteBatch.Begin(SpriteSortMode.BackToFront, BlendState.AlphaBlend);
                // spriteBatch.Draw(Player4_Texture, Player4_Position, Color.White);
                // spriteBatch.End();
    
          //      spriteBatch.Begin();
          //      spriteBatch.Draw(HUD_Crosshair_Texture, HUD_Crosshair_Position, Color.White);
            //    spriteBatch.End();
    
                if (Fireball_Enabled == true)
                {
                    spriteBatch.Begin(SpriteSortMode.BackToFront, BlendState.AlphaBlend);
                    spriteBatch.Draw(Fireball_Texture, Fireball_Position, Color.White);
                    spriteBatch.End();
                }
    
                // Add code above
                base.Draw(gameTime);
            }
    
            private void Draw_Scenery()
            {
            }
            private void Draw_Player()
            {
            }
            private void Draw_HUD()
            {
            }
            private void Draw_Team()
            {
            }
            private void Draw_Enemy()
            {
            }
        }
    }</soundeffect> </soundeffect></soundeffect></soundeffect></model></texture2d></texture2d></texture2d></texture2d></texture2d></texture2d></texture2d></texture2d></texture2d></texture2d></texture2d></texture2d></texture2d></texture2d></texture2d></texture2d></texture2d>
    


  • That mod looks awesome IceIYIaN, though I am still trying to work out what is about. Good luck with it.


Log in to reply