Beiträge von Jok3r

Jok3r

Dieser Name gibt es schon für ein Online Shooter im 2D Game.
Ich wäre für Core-Soldier

Jok3r

Zitat von Taser;228049

Wtf????? Was soll das?

Der Beitrag vom Threadersteller muss erst freigeschalten werden weil er ihn bearbeitet hat, und er weniger als 10 posts hat
deswegen is der thread für uns nicht sichtbar

Jok3r

Für mich ist das Tutorial nur aus irgentwelchen sachen zusammengesetzt.
Und das auch noch schlecht, was bringt es User die sich auf Spieleprogrammierung spezalisieren,
und dan so etwas sehen. Das ist tut mir leid aber Augenkrebs in meinen Augen.

Ich z.B Programmiere gerade ein Spiel, und wen ich das Anwenden würde was du hier schreibst...
ayayay sag ich da nur. Schau du dir am besten nochmal Tutorials an bevor du welche schreibst.

So etwas wie Internefreaks sein Tutorial ist ein richtiges:
http://www.mmorpg-core.com/forum/tutorial…ngen-21957.html

Ich behaupte nicht das du keine Ahnung davon hast, aber von jedem tutorial das ich von dir lese kommt es mir
so vor.

Jok3r

Seit wan darf man sachen die man Kauft ins Netz stellen wtf?
Also sry, dümmer geht es nicht.
Wo macht das Unternehmen seinen Gewinn wen sie es nureinmal verkaufen und der Käufer stellt dan
das Produkt ins Netz...
Das ist failed²
Das du dich nicht schämst sowas zu schreiben... also echt mal

Jok3r

Das beste Tutorial, was ich seit langem gelesen habe!!
Man sieht wiviel Arbeit darinsteckt.
Ist wirklich Super geworden. Das Tutorial macht Spaß zu lesen, und es ist alles wunderbar eklärt.
Wirklich Klasse sache, mach weiter so!

Jok3r

Zitat von Infected;227870

Les den Thread ~
Er ->sucht<- Vs2003 , er will es -> nicht kaufen <-

Er hat was gesucht ich hab ihm den Link zum kaufen geschickt.
Ich bitte dich ein bischen mehr dein Kopf anzustrengen.

Jok3r

Schau dir am besten genau das alte Madrigal an.
Schau dir den Aufbau der Welt an.

Du musst bedenken das du Monster Spawnen musst.
Große Flächen machen in der man sich frei bewegen kann, aber nicht alzugroße.
Natürlich dafst du die wichtigsten NPC's nicht vergessen, dan musst du
dein neues Madrigal auf deine Questreihe anpassen.

Es gibt sehr viele Punkte worauf du achten musst.

Jok3r

Wen du betrügst, betrügst du keinen anderen sondern nur dich,
den du lernst nichts dabei.

Jok3r

Warez wird hier doch nicht erlaubt soviel ich weis ;)

Hier kannst du Visual Studio 2003 kaufen
Amazon.com: Microsoft Visual Studio .NET Professional 2003: Software

Jok3r

Für das Spiel das ich gerade Programmiere, ist das die beste Lösung finde ich zumindestens.
Man kann es natürlich auch anderster sehen.

Jok3r

Gute Tag liebe XNA Freunde

Hiermit Release ich für euch das Audio Input für eure Spiele.
Es ist schon alles perfekt eingestellt. Ihr müsst es nur noch an eurem
XNA Game anpassen.

Code

C#

/*//---------------------------------------------------//
 * Audio.cs                                         *
 * Microsoft XNA Game Platform                      *  
 * Adventure of Kanaarh                             *           
 * Copyright (C) Jok3r                              *
 * Copyright (C) Kevin Kaymak. All rights reserved  *
 */
//--------------------------------------------------//


using System;
using System.Collections.Generic;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;


namespace AdventureofK
{
    public class Audio : GameComponent
    {
        private static Audio audio = null;
        private AudioEngine audioEngine;
        private SoundBank soundBank;
        private WaveBank waveBank;
        private Audio(Game game, string settingsFile, string waveBankFile, string soundBankFile)
            : base(game)
        {
            try
            {
                audioEngine = new AudioEngine(settingsFile);
                waveBank = new WaveBank(audioEngine, waveBankFile);
                soundBank = new SoundBank(audioEngine, soundBankFile);
            }
            catch (NoAudioHardwareException)
            {
                audioEngine = null;
                waveBank = null;
                soundBank = null;
            }
        }
        public static void Initialize(Game game, string settingsFile, string waveBankFile, string soundBankFile)
        {
            audio = new Audio(game, settingsFile, waveBankFile, soundBankFile);
            if (game != null)
            {
                game.Components.Add(audio);
            }
        }
        public static Cue GetCue(string cueName)
        {
            if (String.IsNullOrEmpty(cueName) ||
                (audio == null) || (audio.audioEngine == null) ||
                (audio.soundBank == null) || (audio.waveBank == null))
            {
                return null;
            }
            return audio.soundBank.GetCue(cueName);
        }
        public static void PlayCue(string cueName)
        {
            if ((audio != null) && (audio.audioEngine != null) &&
                (audio.soundBank != null) && (audio.waveBank != null))
            {
                audio.soundBank.PlayCue(cueName);
            }
        }


        private Cue musicCue;
        private Stack<string> musicCueNameStack = new Stack<string>();
        public static void PlayMusic(string cueName)
        {
            if (audio != null)
            {
                audio.musicCueNameStack.Clear();
                PushMusic(cueName);
            }
        }


        public static void PushMusic(string cueName)
        {
            if ((audio != null) && (audio.audioEngine != null) &&
                (audio.soundBank != null) && (audio.waveBank != null))
            {
                audio.musicCueNameStack.Push(cueName);
                if ((audio.musicCue == null) ||
                    (audio.musicCue.Name != cueName))
                {
                    if (audio.musicCue != null)
                    {
                        audio.musicCue.Stop(AudioStopOptions.AsAuthored);
                        audio.musicCue.Dispose();
                        audio.musicCue = null;
                    }
                    audio.musicCue = GetCue(cueName);
                    if (audio.musicCue != null) ;
                    {
                        audio.musicCue.Play();
                    }
                }
            }
        }
        public static void PopMusic()
        {
            if ((audio != null) && (audio.audioEngine != null) &&
                (audio.soundBank != null) && (audio.waveBank != null))
            {
                string cueName = null;
                if (audio.musicCueNameStack.Count > 0)
                {
                    audio.musicCueNameStack.Pop();
                    if (audio.musicCueNameStack.Count > 0)
                    {
                        cueName = audio.musicCueNameStack.Peek();
                    }
                }
                if ((audio.musicCue == null) ||
                    (audio.musicCue.Name != cueName))
                {
                    if (audio.musicCue != null)
                    {
                        audio.musicCue.Stop(AudioStopOptions.AsAuthored);
                        audio.musicCue.Dispose();
                        audio.musicCue = null;
                    }
                    if (!String.IsNullOrEmpty(cueName))
                    {
                        audio.musicCue = GetCue(cueName);
                        if (audio.musicCue != null)
                        {
                            audio.musicCue.Play();
                        }
                    }
                }
            }
        }
        public static void StopMusic()
        {
            if (audio != null)
            {
                audio.musicCueNameStack.Clear();
                if (audio.musicCue != null)
                {
                    audio.musicCue.Stop(AudioStopOptions.AsAuthored);
                    audio.musicCue.Dispose();
                    audio.musicCue = null;
                }
            }
        }
        public override void Update(GameTime gameTime)
        {
            if (audioEngine != null)
            {
                audioEngine.Update();
            }
            base.Update(gameTime);
        }
        protected override void Dispose(bool disposing)
        {
            try
            {
                if (disposing)
                {
                    StopMusic();
                    if (soundBank != null)
                    {
                        soundBank.Dispose();
                        soundBank = null;
                    }
                    if (waveBank != null)
                    {
                        waveBank.Dispose();
                        waveBank = null;
                    }
                    if (audioEngine != null)
                    {
                        audioEngine.Dispose();
                        audioEngine = null;
                    }
                }
            }
            finally
            {
                base.Dispose(disposing);
            }
        }
    }
}

Alles anzeigen

Ihr müsst nur euren Namespace anpassen.
Auserdem müsst ihr in eurer Game.cs folgende dinge adden.

im Feld

Code

[COLOR=red]public Game1()[/COLOR]

Code

public Game1()
        {
     
            [COLOR=red] Audio.Initialize(this, @"[B][COLOR=darkorange]Euer Pfad zur Audio.rgs[/COLOR][/B]",
             @"[B][COLOR=darkorange]Euer Pfad zur WaveBank .xwb[/COLOR][/B]", @"[B][COLOR=darkorange]Euer Pfad zur SoundBank.xbs[/COLOR][/B]");[/COLOR]
            
        
        }

und schon könnt ihr euren Sound und eure Musik
im Spiel / XNA verwenden.

Für diesen Code habe ich ca 3 Stunden harte Arbeit gebraucht.

Es sind:
-185 Zeilen
-k.A Absätze
-6.411 Zeichen
- 394 Wörter

Ich werde schauen das ich noch mehr solche Dateien Releasen werde, da ich
ja weniger Zeit habe ein paar XNA Tutorials zu schreiben.

Wer Support brauch bei diesem Code, kann sich gerne an mich wenden.

Jok3r

Ich finde das Intro etwas lange.
Die Zuschauer wollen das Vieo sehen und kein so langes Intro.

Ansonsten recht nice, bis auf den Rechtschreibfehler.
Wünsche euch nochmals viel Glück beim Aufbau eures Kanals!

Jok3r

@ichbinniemand:
Das kann man mit VS nicht zählen.
Internetfreak war so freundlich und hat es Per Word zählen lassen.

Jok3r

Noch ein Tipp,
versucht die Videos mit den Handy anzuschauen d.h
wen einer Internet auf dem Handy hat soll er die Youtube Videos von euch anschauen.
Wen er das macht habt ihr auf einen Schlag ca 3000 Views ;)

Jok3r

Dan wünsche ich euch mal viel Glück.
Wen ihr etwas länger dabei seit und wirklich gute Videos habt
und viele Abonnenten, könntet ihr vll mit diesem Projekt die Youtube Partnerschaft erreichn

Na dann, mögen viele Leute eure Videos schauen.

(kleiner Tipp am rande, macht in die Beschreibbox viele Wörter, so steigt auch die Chance das ihr durch die Suchfunktion gefunden werdet)

Jok3r

Es giebt mehrer möglichkeiten, wiso das nicht funktioniert.
Doch am besten wäre es wen du uns deinen Code nochmal Posten würdest und nicht das vom Tutorials
eventuell hast du doch einen Fehler gemacht.

Es könnte auch eventuell daran liegen das die PHP Datei keine Berechtigung hat die Daten in MSSQL einzutragen.
Es kann auch an anderen dingen liegen.

Jok3r

Gute Tag liebe XNA Freunde

Hiermit Release ich für euch die Xbox360 & Keyboard Controll Funktion.
Es ist schon alles perfekt eingestellt. Ihr müsst es nur noch an eurem
XNA Game anpassen.

Code

C#

/*//---------------------------------------------------//
 * GameControl.cs                                   *
 * Microsoft XNA Game Platform                      *  
 * Adventure of Kanaarh                             *           
 * Copyright (C) Jok3r                              *
 * Copyright (C) Kevin Kaymak. All rights reserved  *
 *///--------------------------------------------------//


using System;
using System.Collections.Generic;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Input;


namespace AdventureofK
{
    public static class GameControl
    {
        public enum Action
        {
            MainMenu,
            Ok,
            Back,
            CharackterManagment,
            Exit,
            TakeView,
            DropUnEquip,
            MoveUp,
            MoveDown,
            MoveLeft,
            MoveRight,
            CursorUp,
            CursorDown,
            DecreaseAmount,
            IncreaseAmount,
            PageLeft,
            PageRight,
            TargetUp,
            TargetDown,
            ActiveLeft,
            ActiveRight,
            TotalActionCount,
        }


        private static readonly string[] actionNames =
        {
            "Haupt Menü",
            "Ok",
            "Zurück",
            "Charackter Auswahl",
            "Spiel Beenden",
            "Nehmen/Ansehen",
            "Drop/Unequip",
            "Move - Up",
            "Move - Down",
            "Move - Right",
            "Move Cursor - Up",
            "Move Cursor - Down",
            "Decrease Amount",
            "Increase Amount",
            "Page Left",
            "Page Right",
            "Target Up",
            "Target Down",
            "Select Char Left",
            "Select Char Right",
    };
        public static string GetActionName(Action action)
        {
            int index = (int)action;
            if ((index < 0) || (index > actionNames.Length))
            {
                throw new ArgumentException("action");
            }
            return actionNames[index];
        }


        public enum GamePadButtons
        {
            Start,
            Back,
            A,
            B,
            X,
            Y,
            Up,
            Down,
            Left,
            Right,
            LeftSchoulder,
            RightSchoulder,
            LeftTrigger,
            RightTrigger,
        }


        public class ActionMap
        {
            public List<GamePadButtons> gamePadButtons = new List<GamePadButtons>();
            public List<Keys> keyboardKeys = new List<Keys>();
        }


        const float analogLimit = 0.5f;


        public static KeyboardState currentKeyboardState;
        public static KeyboardState CurrentKeyboardState
        {
            get { return currentKeyboardState; }
        }


        private static KeyboardState previousKeyboardState;
        public static bool IsKeyPressed(Keys key)
        {
            return currentKeyboardState.IsKeyDown(key);
        }


        public static bool IsKeyTriggered(Keys key)
        {
            return (currentKeyboardState.IsKeyDown(key)) &&
                (!previousKeyboardState.IsKeyDown(key));
        }


        //GamePad Controlls


        private static GamePadState currentGamePadState;
        private static GamePadState CurrentGamePadState
        {
            get { return currentGamePadState; }
        }


        private static GamePadState previousGamePadState;
        public static bool IsGamePadStartPressed()
        {
            return (currentGamePadState.Buttons.Start == ButtonState.Pressed);
        }


        public static bool IsGamePadBackPressed()
        {
            return (currentGamePadState.Buttons.Back == ButtonState.Pressed);
        }


        public static bool IsGamePadAPressed()
        {
            return (currentGamePadState.Buttons.A == ButtonState.Pressed);
        }


        public static bool IsGamePadBPressed()
        {
            return (currentGamePadState.Buttons.B == ButtonState.Pressed);
        }


        public static bool IsGamePadXPressed()
        {
            return (currentGamePadState.Buttons.X == ButtonState.Pressed);
        }


        public static bool IsGamePadYkPressed()
        {
            return (currentGamePadState.Buttons.Y == ButtonState.Pressed);
        }


        public static bool IsGamePadLeftShoulderPressed()
        {
            return (currentGamePadState.Buttons.LeftShoulder == ButtonState.Pressed);
        }


        public static bool IsGamePadRightShoulderPressed()
        {
            return (currentGamePadState.Buttons.RightShoulder == ButtonState.Pressed);
        }


        public static bool IsGamePadDPadDownPressed()
        {
            return (currentGamePadState.DPad.Down == ButtonState.Pressed);
        }


        public static bool IsGamePadDPadUpPressed()
        {
            return (currentGamePadState.DPad.Up == ButtonState.Pressed);
        }


        public static bool IsGamePadDPadLeftPressed()
        {
            return (currentGamePadState.DPad.Left == ButtonState.Pressed);
        }


        public static bool IsGamePadDPadRightPressed()
        {
            return (currentGamePadState.DPad.Right == ButtonState.Pressed);
        }


        public static bool IsGamePadLeftTriggerPressed()
        {
            return (currentGamePadState.Triggers.Left > analogLimit);
        }


        public static bool IsGamePadRightTriggerPressed()
        {
            return (currentGamePadState.Triggers.Right > analogLimit);
        }


        public static bool IsGamePadLeftStickUpPressed()
        {
            return (currentGamePadState.ThumbSticks.Left.Y > analogLimit);
        }


        public static bool IsGamePadLeftStickDownPressed()
        {
            return (-1f * currentGamePadState.ThumbSticks.Left.Y > analogLimit);
        }


        public static bool IsGamePadLeftStickLeftPressed()
        {
            return (-1f * currentGamePadState.ThumbSticks.Left.X > analogLimit);
        }


        public static bool IsGamePadLeftStickRightPressed()
        {
            return (currentGamePadState.ThumbSticks.Left.X > analogLimit);
        }


        private static bool IsGamePadButtonsPressed(GamePadButtons gamePadKey)
        {
            switch (gamePadKey)
            {
                case GamePadButtons.Start:
                    return IsGamePadStartPressed();


                case GamePadButtons.Back:
                    return IsGamePadBackPressed();




                case GamePadButtons.A:
                    return IsGamePadAPressed();




                case GamePadButtons.B:
                    return IsGamePadBPressed();




                case GamePadButtons.X:
                    return IsGamePadXPressed();




                case GamePadButtons.LeftSchoulder:
                    return IsGamePadLeftShoulderPressed();




                case GamePadButtons.RightSchoulder:
                    return IsGamePadRightShoulderPressed();




                case GamePadButtons.LeftTrigger:
                    return IsGamePadLeftTriggerPressed();




                case GamePadButtons.RightTrigger:
                    return IsGamePadRightTriggerPressed();




                case GamePadButtons.Up:
                    return IsGamePadDPadUpPressed() ||
                        IsGamePadLeftStickUpPressed();


                case GamePadButtons.Down:
                    return IsGamePadDPadDownPressed() ||
                        IsGamePadLeftStickDownPressed();


                case GamePadButtons.Left:
                    return IsGamePadDPadLeftPressed() ||
                        IsGamePadLeftStickLeftPressed();


                case GamePadButtons.Right:
                    return IsGamePadDPadRightPressed() ||
                        IsGamePadLeftStickRightPressed();
            }


            return false;
        }


        //Gamepad Triggers


        public static bool IsGamePadStartTriggered()
        {
            return ((currentGamePadState.Buttons.Start == ButtonState.Pressed) &&
                (previousGamePadState.Buttons.Start == ButtonState.Released));
        }


        public static bool IsGamePadBackTriggered()
        {
            return ((currentGamePadState.Buttons.Back == ButtonState.Pressed) &&
                (previousGamePadState.Buttons.Back == ButtonState.Released));
        }


        public static bool IsGamePadATriggered()
        {
            return ((currentGamePadState.Buttons.A == ButtonState.Pressed) &&
                (previousGamePadState.Buttons.A == ButtonState.Released));
        }


        public static bool IsGamePadBTriggered()
        {
            return ((currentGamePadState.Buttons.B == ButtonState.Pressed) &&
                (previousGamePadState.Buttons.B == ButtonState.Released));
        }


        public static bool IsGamePadXTriggered()
        {
            return ((currentGamePadState.Buttons.X == ButtonState.Pressed) &&
                (previousGamePadState.Buttons.X == ButtonState.Released));
        }


        public static bool IsGamePadYTriggered()
        {
            return ((currentGamePadState.Buttons.Y == ButtonState.Pressed) &&
                (previousGamePadState.Buttons.Y == ButtonState.Released));
        }


        public static bool IsGamePadLeftShoulderTriggered()
        {
            return ((currentGamePadState.Buttons.LeftShoulder == ButtonState.Pressed) &&
                (previousGamePadState.Buttons.LeftShoulder == ButtonState.Released));
        }


        public static bool IsGamePadRightShoulderTriggered()
        {
            return ((currentGamePadState.Buttons.RightShoulder == ButtonState.Pressed) &&
                (previousGamePadState.Buttons.RightShoulder == ButtonState.Released));
        }


        public static bool IsGamePadDPatUpTriggered()
        {
            return ((currentGamePadState.DPad.Up == ButtonState.Pressed) &&
                (previousGamePadState.DPad.Up == ButtonState.Released));
        }


        public static bool IsGamePadDPatDownTriggered()
        {
            return ((currentGamePadState.DPad.Down == ButtonState.Pressed) &&
                (previousGamePadState.DPad.Down == ButtonState.Released));
        }


        public static bool IsGamePadDPatLeftTriggered()
        {
            return ((currentGamePadState.DPad.Left == ButtonState.Pressed) &&
                (previousGamePadState.DPad.Left == ButtonState.Released));
        }


        public static bool IsGamePadDPatRightTriggered()
        {
            return ((currentGamePadState.DPad.Right == ButtonState.Pressed) &&
                (previousGamePadState.DPad.Right == ButtonState.Released));
        }


        public static bool IsGamePadLeftTriggerTriggered()
        {
            return ((currentGamePadState.Triggers.Left > analogLimit) &&
                (previousGamePadState.Triggers.Left > analogLimit));
        }


        public static bool IsGamePadRightTriggerTriggered()
        {
            return ((currentGamePadState.Triggers.Right > analogLimit) &&
                (previousGamePadState.Triggers.Right > analogLimit));
        }


        public static bool IsGamePadLeftStickUpTriggered()
        {
            return ((currentGamePadState.ThumbSticks.Left.Y > analogLimit) &&
                (previousGamePadState.ThumbSticks.Left.Y > analogLimit));
        }


        public static bool IsGamePadLeftStickDownTriggered()
        {
            return ((-1f * currentGamePadState.ThumbSticks.Left.Y > analogLimit) &&
                (-1f * previousGamePadState.ThumbSticks.Left.Y > analogLimit));
        }


        public static bool IsGamePadLeftStickLeftTriggered()
        {
            return ((-1f * currentGamePadState.ThumbSticks.Left.X > analogLimit) &&
                (-1f * previousGamePadState.ThumbSticks.Left.X > analogLimit));
        }


        public static bool IsGamePadLeftStickRightTriggered()
        {
            return ((currentGamePadState.ThumbSticks.Left.X > analogLimit) &&
                (previousGamePadState.ThumbSticks.Left.X > analogLimit));
        }


        private static bool IsGamePadButtonTriggered(GamePadButtons gamePadKey)
        {
            switch (gamePadKey)
            {
                case GamePadButtons.Start:
                    return IsGamePadStartTriggered();


                case GamePadButtons.Back:
                    return IsGamePadBackTriggered();


                case GamePadButtons.A:
                    return IsGamePadATriggered();


                case GamePadButtons.B:
                    return IsGamePadBTriggered();


                case GamePadButtons.X:
                    return IsGamePadXTriggered();


                case GamePadButtons.Y:
                    return IsGamePadYTriggered();


                case GamePadButtons.LeftSchoulder:
                    return IsGamePadLeftShoulderTriggered();


                case GamePadButtons.RightSchoulder:
                    return IsGamePadRightShoulderTriggered();


                case GamePadButtons.LeftTrigger:
                    return IsGamePadLeftTriggerTriggered();


                case GamePadButtons.RightTrigger:
                    return IsGamePadRightTriggerTriggered();


                case GamePadButtons.Up:
                    return IsGamePadDPatUpTriggered() ||
                        IsGamePadLeftStickUpTriggered();


                case GamePadButtons.Down:
                    return IsGamePadDPatDownTriggered() ||
                        IsGamePadLeftStickDownTriggered();


                case GamePadButtons.Left:
                    return IsGamePadDPatLeftTriggered() ||
                        IsGamePadLeftStickLeftTriggered();


                case GamePadButtons.Right:
                    return IsGamePadDPatRightTriggered() ||
                        IsGamePadLeftStickRightTriggered();
            }
            return false;
        }


        //Action Mapping Game


        private static ActionMap[] actionMaps;


        public static ActionMap[] ActionMaps
        {
            get { return actionMaps; }
        }


        private static void ResetActionMaps()
        {
            actionMaps = new ActionMap[(int)Action.TotalActionCount];
            actionMaps[(int)Action.MainMenu] = new ActionMap();
            actionMaps[(int)Action.MainMenu].keyboardKeys.Add(Keys.Tab);
            actionMaps[(int)Action.MainMenu].gamePadButtons.Add(GamePadButtons.Start);
            actionMaps[(int)Action.Ok] = new ActionMap();
            actionMaps[(int)Action.Ok].keyboardKeys.Add(Keys.Enter);
            actionMaps[(int)Action.Ok].gamePadButtons.Add(GamePadButtons.A);
            actionMaps[(int)Action.Back] = new ActionMap();
            actionMaps[(int)Action.Back].keyboardKeys.Add(Keys.Escape);
            actionMaps[(int)Action.Back].gamePadButtons.Add(GamePadButtons.B);
            actionMaps[(int)Action.CharackterManagment] = new ActionMap();
            actionMaps[(int)Action.CharackterManagment].keyboardKeys.Add(Keys.Space);
            actionMaps[(int)Action.CharackterManagment].gamePadButtons.Add(GamePadButtons.Y);
            actionMaps[(int)Action.Exit] = new ActionMap();
            actionMaps[(int)Action.Exit].keyboardKeys.Add(Keys.Escape);
            actionMaps[(int)Action.Exit].gamePadButtons.Add(GamePadButtons.Back);
            actionMaps[(int)Action.TakeView] = new ActionMap();
            actionMaps[(int)Action.TakeView].keyboardKeys.Add(Keys.LeftControl);
            actionMaps[(int)Action.TakeView].gamePadButtons.Add(GamePadButtons.Y);
            actionMaps[(int)Action.DropUnEquip] = new ActionMap();
            actionMaps[(int)Action.DropUnEquip].keyboardKeys.Add(Keys.D);
            actionMaps[(int)Action.DropUnEquip].gamePadButtons.Add(GamePadButtons.X);
            actionMaps[(int)Action.MoveUp] = new ActionMap();
            actionMaps[(int)Action.MoveUp].keyboardKeys.Add(Keys.Up);
            actionMaps[(int)Action.MoveUp].gamePadButtons.Add(GamePadButtons.Up);
            actionMaps[(int)Action.MoveDown] = new ActionMap();
            actionMaps[(int)Action.MoveDown].keyboardKeys.Add(Keys.Down);
            actionMaps[(int)Action.MoveDown].gamePadButtons.Add(GamePadButtons.Down);
            actionMaps[(int)Action.MoveLeft] = new ActionMap();
            actionMaps[(int)Action.MoveLeft].keyboardKeys.Add(Keys.Left);
            actionMaps[(int)Action.MoveLeft].gamePadButtons.Add(GamePadButtons.Left);
            actionMaps[(int)Action.MoveRight] = new ActionMap();
            actionMaps[(int)Action.MoveRight].keyboardKeys.Add(Keys.Right);
            actionMaps[(int)Action.MoveRight].gamePadButtons.Add(GamePadButtons.Right);
            actionMaps[(int)Action.CursorUp] = new ActionMap();
            actionMaps[(int)Action.CursorUp].keyboardKeys.Add(Keys.Up);
            actionMaps[(int)Action.CursorUp].gamePadButtons.Add(GamePadButtons.Up);
            actionMaps[(int)Action.CursorDown] = new ActionMap();
            actionMaps[(int)Action.CursorDown].keyboardKeys.Add(Keys.Down);
            actionMaps[(int)Action.CursorDown].gamePadButtons.Add(GamePadButtons.Down);
            actionMaps[(int)Action.DecreaseAmount] = new ActionMap();
            actionMaps[(int)Action.DecreaseAmount].keyboardKeys.Add(Keys.Left);
            actionMaps[(int)Action.DecreaseAmount].gamePadButtons.Add(GamePadButtons.Left);
            actionMaps[(int)Action.IncreaseAmount] = new ActionMap();
            actionMaps[(int)Action.IncreaseAmount].keyboardKeys.Add(Keys.Right);
            actionMaps[(int)Action.IncreaseAmount].gamePadButtons.Add(GamePadButtons.Right);
            actionMaps[(int)Action.PageLeft] = new ActionMap();
            actionMaps[(int)Action.PageLeft].keyboardKeys.Add(Keys.LeftShift);
            actionMaps[(int)Action.PageLeft].gamePadButtons.Add(GamePadButtons.LeftTrigger);
            actionMaps[(int)Action.PageRight] = new ActionMap();
            actionMaps[(int)Action.PageRight].keyboardKeys.Add(Keys.RightShift);
            actionMaps[(int)Action.PageRight].gamePadButtons.Add(GamePadButtons.RightTrigger);
            actionMaps[(int)Action.TargetUp] = new ActionMap();
            actionMaps[(int)Action.TargetUp].keyboardKeys.Add(Keys.Up);
            actionMaps[(int)Action.TargetUp].gamePadButtons.Add(GamePadButtons.Up);
            actionMaps[(int)Action.TargetDown] = new ActionMap();
            actionMaps[(int)Action.TargetDown].keyboardKeys.Add(Keys.Down);
            actionMaps[(int)Action.TargetDown].gamePadButtons.Add(GamePadButtons.Down);
            actionMaps[(int)Action.ActiveLeft] = new ActionMap();
            actionMaps[(int)Action.ActiveLeft].keyboardKeys.Add(Keys.Left);
            actionMaps[(int)Action.ActiveLeft].gamePadButtons.Add(GamePadButtons.Left);
            actionMaps[(int)Action.ActiveRight] = new ActionMap();
            actionMaps[(int)Action.ActiveRight].keyboardKeys.Add(Keys.Right);
            actionMaps[(int)Action.ActiveRight].gamePadButtons.Add(GamePadButtons.Right);
        }


        public static bool IsActionPressed(Action action)
        {
            return IsActionMapPressed(actionMaps[(int)action]);
        }


        public static bool IsActionTriggered(Action action)
        {
            return IsActionMapTriggered(actionMaps[(int)action]);
        }


        private static bool IsActionMapPressed(ActionMap actionMap)
        {
            for (int i = 0; i < actionMap.keyboardKeys.Count; i++)
            {
                if (IsKeyPressed(actionMap.keyboardKeys[i]))
                {
                    return true;
                }
            }
            if (currentGamePadState.IsConnected)
            {
                for (int i = 0; i < actionMap.gamePadButtons.Count; i++)
                {
                    if (IsGamePadButtonsPressed(actionMap.gamePadButtons[i]))
                    {
                        return true;
                    }
                }
            }
            return false;
        }


        private static bool IsActionMapTriggered(ActionMap actionMap)
        {
            for (int i = 0; i < actionMap.gamePadButtons.Count; i++)
            {
                if (IsGamePadButtonTriggered(actionMap.gamePadButtons[i]))
                {
                    return true;
                }
            }


            if (currentGamePadState.IsConnected)
            {
                for (int i = 0; i < actionMap.gamePadButtons.Count; i++)
                {
                    if (IsGamePadButtonTriggered(actionMap.gamePadButtons[i]))
                    {
                        return true;
                    }
                }
            }
            return false;
        }


        public static void Initialize()
        {
            ResetActionMaps();
        }


        public static void Update()
        {
            //Update Keyboard
            previousKeyboardState = currentKeyboardState;
            currentKeyboardState = Keyboard.GetState();


            //Update Gamepade
            previousGamePadState = currentGamePadState;
            currentGamePadState = GamePad.GetState(PlayerIndex.One);
        }
    }
}

Alles anzeigen

Ihr müsst nur euren Namespace anpassen.
Auserdem müsst ihr in eurer Game.cs folgende dinge adden.

im feld

Code

[COLOR=red]protected override void Initialize[/COLOR]

Code

protected override void Initialize()
        {
            


           [COLOR=red]  GameControl.Initialize();[/COLOR]
             
        
             
        }

und im feld

Code

[COLOR=red]protected override void Update(GameTime gameTime)[/COLOR]

Code

protected override void Update(GameTime gameTime)
        {
           [COLOR=red] GameControl.Update();[/COLOR]
            
        }

und schon könnt ihr euren Xbox Controller benutzen und eure
Tastaturbelegung anpassen!

Für diesen Code habe ich ca 2 Tage harte Arbeit gebraucht.

Es sind:
-600 Zeilen
-493 Absätze
-20.564 Zeichen
-1.143 Wörter

Ich werde schauen das ich noch mehr solche Dateien Releasen werde, da ich
ja weniger Zeit habe ein paar XNA Tutorials zu schreiben.

Wer Support brauch bei diesem Code, kann sich gerne an mich wenden.

Jok3r

Ich freue mich schon drauf,
habe ja schon ein bischen gesehen.
Und pass auf das du die Zeichenbegrenzung nicht überschreitest so wie du gerade am Tut schreiben bist ;)

Jok3r

Rising Gods
Viele Player, Super GMS
PVE und PVP Server
und ein anständiges developer Team

Jok3r

Stimme da meinen lieben Internetfreak voll und ganz zu.
Das Tutorial ist viel besser als vorherige. Auserdem etwas übersichtlicher.
Was mich wunder ist, wiso du überall ein <summary></summary> gemacht hast.
für ein Tutorial reicht doch ein ganz einfaches // Kommentar. Den ein summary bringt
meistens viele Anfänger durcheinander, da es für sie dan komplezierter aussieht.

Aufjedenfall ist es gut geworden das Tutorial.
Das nächste mal erklärst du vll was Vector ist etc.

Ich selber würde ja auch gerne ein paar kleine Tutorials dazu schreiben.
Habe aber jetzt da ich mit XNA ein RPG Spiel Programmiere keine Zeit mehr.

Mach aber weiter so!!

Beiträge von Jok3r

[Mmorpg-Core.com Browsergame] Name?

Dark-Side|Neue Waffen|Neue Welten vieles mehr !!

Tutorial 5: Das erste 2D Game: Angriffe und leben

[Suche]microsoft visual studio .net 2003

XNA-Tutorialserie Teil 1: Vorbereitung und Erklärungen

[Suche]microsoft visual studio .net 2003

Neues Madrigal

Für alle Schüler :D

[Suche]microsoft visual studio .net 2003

XNA Audio Input

XNA Audio Input

[GamersNoise] Showroom

XNA Game Control Xbox360 & Keyboard

[GamersNoise] Info

[GamersNoise] Info

Verbindung zu SQL klappt nicht (Regi Page)

XNA Game Control Xbox360 & Keyboard

[Ankündigung] Tutorialserie.

Bester WoW P-Server (Blizzard like)

Tutorial 2: Das erste 2D Game: Benötigte Objekte und Variablen

SCHNELLZUGRIFF

HILFE & COMMUNITY

RECHTLICHES