console

[PedroAlvesq]

how i put my show my console en i press enter and i press enter hide if the msg in empy becouse i don´t want write some mistake en i move the character this is my code

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.GamerServices;
using TomShane.Neoforce.Controls;
using XRpgLibrary;
using System.Threading;
using System.Security.Cryptography;
using System.Security;
using Microsoft.Xna.Framework.Input;
//using HeightmapCollisionPipeline;

namespace TomShane.Neoforce.Central.Code
{
    public class Gameplays : BaseGameState
    {
        const float SphereVelocity = 2;
       // GraphicsDeviceManager graphics1;
        // how quickly the sphere can turn from side to side
        const float SphereTurnSpeed = .025f;

        // the radius of the sphere. We'll use this to keep the sphere above the ground,
        // and when computing how far the sphere has rolled.
        const float SphereRadius = 13.0f;

        // This vector controls how much the camera's position is offset from the
        // sphere. This value can be changed to move the camera further away from or
        // closer to the sphere.
        readonly Vector3 CameraPositionOffset = new Vector3(0, 40, 150);

        // This value controls the point the camera will aim at. This value is an offset
        // from the sphere's position.
        readonly Vector3 CameraTargetOffset = new Vector3(0, 30, 0);
        string text = "admin";
         string texto;
        private Label lbusername = null;
        private Manager NeoManager;
      private  Window inventory;
      private Window Charactersstatus;
        Model terrain;
        //private Window Window { get { return window; } set { window = value; } }
        Matrix projectionMatrix;
        Matrix viewMatrix;

        Vector3 spherePosition;
        float sphereFacingDirection;
        Matrix sphereRollingMatrix = Matrix.Identity;

        Model sphere;
        HeightMapInfo heightMapInfo;

        GraphicsDeviceManager graphics1;
        public Gameplays(Game game, GameStateManager manager, GraphicsDeviceManager graphics)
            : base(game, manager)
        {
          //  Game.Content.RootDirectory = "Content";
            NeoManager = new Manager(game, graphics, "Default");
          graphics1 = graphics;

            //graphics = new GraphicsDeviceManager(Game);
            NeoManager.SkinDirectory = @"C:\Users\Pedro\Dropbox\GAMES\TomShane.Neoforce.Controls.XNA4\Neoforce\Skins";
            NeoManager.AutoUnfocus = false;
           texto = text;
            System.Console.Write(texto);

        }
        protected override void LoadContent()
        {

         terrain = Game.Content.Load<Model>("terrain");

            // The terrain processor attached a HeightMapInfo to the terrain model's
            // Tag. We'll save that to a member variable now, and use it to
            // calculate the terrain's heights later.
            heightMapInfo = terrain.Tag as HeightMapInfo;
            if (heightMapInfo == null)
            {
                string message = "The terrain model did not have a HeightMapInfo " +
                    "object attached. Are you sure you are using the " +
                    "TerrainProcessor?";
                throw new InvalidOperationException(message);
            }

            sphere = Game.Content.Load<Model>("sphere");
            InitConsole(texto);
           Inventory();
           charactersstatus();
            base.LoadContent();

            // NeoManager.Add(sidebar);

        }
        private void Inventory() {
            inventory = new Window(NeoManager);
            inventory.Init();
            inventory.Text = "Inventory";
            inventory.Width = 450;
            inventory.Height = 250;
            inventory.Center();
            inventory.Visible = true;
            inventory.CloseButtonVisible = true;
            inventory.Resizable = false;
            inventory.Movable = true;
            inventory.Close();
            NeoManager.Add(inventory);

        }
        private void charactersstatus()
        {
            Charactersstatus = new Window(NeoManager);
            Charactersstatus.Init();
            Charactersstatus.Text = "Characters Status";
            Charactersstatus.Width = 450;
            Charactersstatus.Height = 250;
            Charactersstatus.Center();
            Charactersstatus.Visible = true;
            Charactersstatus.CloseButtonVisible = true;
            Charactersstatus.Resizable = false;
            Charactersstatus.Movable = true;
            Charactersstatus.Close();
            NeoManager.Add(Charactersstatus);

        }

        public override void Update(GameTime gameTime)
        {

          HandleInput();

           UpdateCamera();
           // StateManager.Update(gameTime);
            //  ControlManager.Update(gameTime, PlayerIndex.One);
            base.Update(gameTime);

            NeoManager.Update(gameTime);

            //   stateManager.PopState();
        }
        public override void Draw(GameTime gameTime)
        {

            //  StateManager.BeginDraw(gameTime);

            NeoManager.BeginDraw(gameTime);

            GraphicsDevice device = graphics1.GraphicsDevice;

            device.Clear(Color.CornflowerBlue);
          //  device.Clear(Color.Black);
            DrawModel(terrain, Matrix.Identity);

            DrawModel(sphere, sphereRollingMatrix *
                Matrix.CreateTranslation(spherePosition));

            NeoManager.EndDraw();

            //   ControlManager.Draw(GameRef.spriteBatch);
            base.Draw(gameTime);

        }
        void DrawModel(Model model, Matrix worldMatrix)
        {
            Matrix[] boneTransforms = new Matrix[model.Bones.Count];
            model.CopyAbsoluteBoneTransformsTo(boneTransforms);

            foreach (ModelMesh mesh in model.Meshes)
            {
                foreach (BasicEffect effect in mesh.Effects)
                {
                    effect.World = boneTransforms[mesh.ParentBone.Index] * worldMatrix;
                    effect.View = viewMatrix;
                    effect.Projection = projectionMatrix;

                    effect.EnableDefaultLighting();
                    effect.PreferPerPixelLighting = true;

                    // Set the fog to match the black background color
                    effect.FogEnabled = true;
                    effect.FogColor = Vector3.Zero;
                    effect.FogStart = 1000;
                    effect.FogEnd = 3200;
                }

                mesh.Draw();
            }
       }

        /// <summary>
        /// Handles input for quitting the game.
        /// </summary>
        private void HandleInput()
        {
            KeyboardState currentKeyboardState = Keyboard.GetState();
            GamePadState currentGamePadState = GamePad.GetState(PlayerIndex.One);

            // Check for exit.

            // Now move the sphere. First, we want to check to see if the sphere should
            // turn. turnAmount will be an accumulation of all the different possible
            // inputs.
            float turnAmount = -currentGamePadState.ThumbSticks.Left.X;
            if (currentKeyboardState.IsKeyDown(Keys.A) ||
                currentKeyboardState.IsKeyDown(Keys.Left) ||
                currentGamePadState.DPad.Left == ButtonState.Pressed)
            {
                turnAmount += 1;
            }
            if (currentKeyboardState.IsKeyDown(Keys.D) ||
                currentKeyboardState.IsKeyDown(Keys.Right) ||
                currentGamePadState.DPad.Right == ButtonState.Pressed)
            {
                turnAmount -= 1;
            }

            // clamp the turn amount between -1 and 1, and then use the finished
            // value to turn the sphere.
            turnAmount = MathHelper.Clamp(turnAmount, -1, 1);
            sphereFacingDirection += turnAmount * SphereTurnSpeed;

            // Next, we want to move the sphere forward or back. to do this, 
            // we'll create a Vector3 and modify use the user's input to modify the Z
            // component, which corresponds to the forward direction.
            Vector3 movement = Vector3.Zero;
            movement.Z = -currentGamePadState.ThumbSticks.Left.Y;

            if (currentKeyboardState.IsKeyDown(Keys.W) ||
                currentKeyboardState.IsKeyDown(Keys.Up) ||
                currentGamePadState.DPad.Up == ButtonState.Pressed)
            {
                movement.Z = -1;
            }

            if (currentKeyboardState.IsKeyDown(Keys.S) ||
                currentKeyboardState.IsKeyDown(Keys.Down) ||
                currentGamePadState.DPad.Down == ButtonState.Pressed)
            {
                movement.Z = 1;
            }
            if (currentKeyboardState.IsKeyDown(Keys.I))
            {
                inventory.Show();
                //windows();

            }
            if (currentKeyboardState.IsKeyDown(Keys.B))
            {
                Charactersstatus.Show();
                //windows();

            }

            // next, we'll create a rotation matrix from the sphereFacingDirection, and
            // use it to transform the vector. If we didn't do this, pressing "up" would
            // always move the ball along +Z. By transforming it, we can move in the
            // direction the sphere is "facing."
            Matrix sphereFacingMatrix = Matrix.CreateRotationY(sphereFacingDirection);
            Vector3 velocity = Vector3.Transform(movement, sphereFacingMatrix);
            velocity *= SphereVelocity;

            // Now we know how much the user wants to move. We'll construct a temporary
            // vector, newSpherePosition, which will represent where the user wants to
            // go. If that value is on the heightmap, we'll allow the move.
            Vector3 newSpherePosition = spherePosition + velocity;
            if (heightMapInfo.IsOnHeightmap(newSpherePosition))
            {
                // finally, we need to see how high the terrain is at the sphere's new
                // position. GetHeight will give us that information, which is offset by
                // the size of the sphere. If we didn't offset by the size of the
                // sphere, it would be drawn halfway through the world, which looks 
                // a little odd.
                newSpherePosition.Y = heightMapInfo.GetHeight(newSpherePosition) +
                    SphereRadius;
            }
            else
            {
                newSpherePosition = spherePosition;
            }

            // now we need to roll the ball "forward." to do this, we first calculate
            // how far it has moved.
            float distanceMoved = Vector3.Distance(spherePosition, newSpherePosition);

            // The length of an arc on a circle or sphere is defined as L = theta * r,
            // where theta is the angle that defines the arc, and r is the radius of
            // the circle.
            // we know L, that's the distance the sphere has moved. we know r, that's
            // our constant "sphereRadius". We want to know theta - that will tell us
            // how much to rotate the sphere. we rearrange the equation to get...
            float theta = distanceMoved / SphereRadius;

            // now that we know how much to rotate the sphere, we have to figure out 
            // whether it will roll forward or backward. We'll base this on the user's
            // input.
            int rollDirection = movement.Z > 0 ? 1 : -1;

            // finally, we'll roll it by rotating around the sphere's "right" vector.
            sphereRollingMatrix *= Matrix.CreateFromAxisAngle(sphereFacingMatrix.Right,
                theta * rollDirection);

            // once we've finished all computations, we can set spherePosition to the
            // new position that we calculated.
            spherePosition = newSpherePosition;
        }

        private void UpdateCamera()
        {
            // The camera's position depends on the sphere's facing direction: when the
            // sphere turns, the camera needs to stay behind it. So, we'll calculate a
            // rotation matrix using the sphere's facing direction, and use it to
            // transform the two offset values that control the camera.
            Matrix cameraFacingMatrix = Matrix.CreateRotationY(sphereFacingDirection);
            Vector3 positionOffset = Vector3.Transform(CameraPositionOffset,
                cameraFacingMatrix);
            Vector3 targetOffset = Vector3.Transform(CameraTargetOffset,
                cameraFacingMatrix);

            // once we've transformed the camera's position offset vector, it's easy to
            // figure out where we think the camera should be.
            Vector3 cameraPosition = spherePosition + positionOffset;

            // We don't want the camera to go beneath the heightmap, so if the camera is
            // over the terrain, we'll move it up.
            if (heightMapInfo.IsOnHeightmap(cameraPosition))
            {
                // we don't want the camera to go beneath the terrain's height +
                // a small offset.
                float minimumHeight =
                    heightMapInfo.GetHeight(cameraPosition) + CameraPositionOffset.Y;

                if (cameraPosition.Y < minimumHeight)
                {
                    cameraPosition.Y = minimumHeight;
                }
            }

            // next, we need to calculate the point that the camera is aiming it. That's
            // simple enough - the camera is aiming at the sphere, and has to take the 
            // targetOffset into account.
            Vector3 cameraTarget = spherePosition + targetOffset;

            // with those values, we'll calculate the viewMatrix.
            viewMatrix = Matrix.CreateLookAt(cameraPosition,
                                              cameraTarget,
                                              Vector3.Up);
        }
        public override void Initialize()
        {

            projectionMatrix = Matrix.CreatePerspectiveFieldOfView(
             MathHelper.ToRadians(45.0f), Game.GraphicsDevice.Viewport.AspectRatio, 1f, 10000);

            NeoManager.Initialize();
            //   StateManager.Initialize();
            base.Initialize();

            //  NeoManager.Initialize();
        }
         private void InitConsole(string texto)
        {
            lbusername = new Label(NeoManager);

            TomShane.Neoforce.Controls.TabControl tbc = new TomShane.Neoforce.Controls.TabControl(NeoManager);
            TomShane.Neoforce.Controls.Console con1 = new TomShane.Neoforce.Controls.Console(NeoManager);
            TomShane.Neoforce.Controls.Console con2 = new TomShane.Neoforce.Controls.Console(NeoManager);
            //TomShane.Neoforce.Controls.Console con3 = new TomShane.Neoforce.Controls.Console(Manager);
            //Console con3 = new Console(Manager);

            // Setup of TabControl, which will be holding both consoles
            tbc.Init();
        //     tbc.StayOnBack=true;
            tbc.AddPage("Global");
            tbc.AddPage("Guild");
            tbc.AddPage("PARTY");
            tbc.AddPage("TRADE");
            tbc.Alpha = 220;
            tbc.Left = 0;
            tbc.Height = 220;
            tbc.Width = 400;
            tbc.Top = NeoManager.TargetHeight - tbc.Height - 32;
            // tbc.Focused = fals;

            tbc.Movable = false;
            tbc.Resizable = false;
            tbc.MinimumHeight = 96;
            tbc.MinimumWidth = 160;

            tbc.TabPages[0].Add(con1);
            tbc.TabPages[1].Add(con2);

            //tbc.TabPages[2].Add(con3);

            con1.Init();
            con1.Sender = texto;
            con2.Init();
            con2.Sender = texto;
            //con3.Init();
            con2.Width = con1.Width = tbc.TabPages[0].ClientWidth;
            con2.Height = con1.Height = tbc.TabPages[0].ClientHeight;
            con2.Anchor = con1.Anchor = Anchors.All;
            con1.Channels.Add(new ConsoleChannel(0, "General", Color.Orange));
            con1.Channels.Add(new ConsoleChannel(1, "Private", Color.White));
            con1.Channels.Add(new ConsoleChannel(2, "System", Color.Yellow));
            con1.Channels.Add(new ConsoleChannel(3, "Guild", Color.GreenYellow));
            con1.Channels.Add(new ConsoleChannel(4, "Trade", Color.Red));
            // We want to share channels and message buffer in both consoles
            con2.Channels = con1.Channels;
            con2.MessageBuffer = con1.MessageBuffer;

            // In the second console we display only "Private" messages
            con2.ChannelFilter.Add(3);

            // Select default channels for each tab
            con1.SelectedChannel = 0;
            con2.SelectedChannel = 3;

            //con3.SelectedChannel = 3;

            // Do we want to add timestamp or channel name at the start of every message?
            con1.MessageFormat = ConsoleMessageFormats.All;

            con2.MessageFormat = ConsoleMessageFormats.All;
            // Handler for altering incoming message
            //  con1.MessageSent += new ConsoleMessageEventHandler(con1_MessageSent);

            // We send initial welcome message to System channel
            con1.MessageBuffer.Add(new ConsoleMessage("System", "WELCOME TO THE SERVER! " + texto, 2));
          //  con2.MessageBuffer.Add(new ConsoleMessage("System", "WELCOME TO THE SERVER! " + texto, 2));

            NeoManager.Add(tbc);

         }
        ////////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////
        void con1_MessageSent(object sender, ConsoleMessageEventArgs e)
        {
            if (e.Message.Channel == 0)
            {
                //e.Message.Text = "(!) " + e.Message.Text;
            }//if(e.Message.Sender
        }
        ////////////////////////////////////////////////////////////////////////////

    }
}

[Grimston]

Copied from email response for reference:

Firstly why use a tab control to store more then 1 console? The console supports channels for that. ;)

The basic way would be to disable the control and change it's visible property to false.

I would also suggest to turning everything into a control, and keep the variables at the top level and not recreate them all the time. (Just hide them while not in use.)

[PedroAlvesq]

i do like this to hide the tabcontrol the problem i can´t put if the console is hide i press in enter and show and only hide if the i don´t put any msg in textbox of the chat

  if (currentKeyboardState.IsKeyDown(Keys.Enter))
            {
                //if(tbc.Visible==true){
                tbc.Visible = false;
               // }
                //else
                //{
                 //   tbc.Show();
                //}

              //  InitConsole(text).Show();
                //windows();

            }