コード例 #1
0
ファイル: MainList.cs プロジェクト: chrwoizi/canyonshooter
        public MainList(ICanyonShooterGame game, string menuName, MenuDescription menuXml, bool hori)
            : base(game as ICanyonShooterGame)
        {
            this.menuXml = menuXml;
            init(menuName, hori);
            this.menuName = menuName;

            foreach (MenupartDescription i in menuXml.MenuParts)
            {
                if (i.Name == menuName)
                {
                    Vector2 ButtonMessure = new Vector2();
                    for (int g = 0; g < i.ButtonCount; g++)
                    {
                        ButtonMessure.X += i.Buttons[g].width;
                        ButtonMessure.Y += i.Buttons[g].height;
                    }
                    this.leftshift = new Button(game, "LeftShift", new Rectangle((int)((game.Graphics.Device.Viewport.Width
                                                                                        - 398 + (i.StartPosition.X - 398)) - 23 - i.ShiftOffset.X), (int)i.StartPosition.Y, 23, 72),
                                                "shift_left", true, this);
                    this.rightshift = new Button(game, "RightShift", new Rectangle((int)(
                                                                                       (game.Graphics.Device.Viewport.Width - 398 + (i.StartPosition.X - 398 - 3))
                                                                                       + i.ShiftOffset.X + ButtonMessure.X + ((i.ButtonCount - 1) * i.Spacer.X)),
                                                                                   (int)i.StartPosition.Y, 23, 72), "shift_right", true, this);
                }
            }
        }
コード例 #2
0
 public NormalList(ICanyonShooterGame game, string menuName, MenuDescription menuXml, bool hori)
     : base(game as ICanyonShooterGame)
 {
     this.menuXml  = menuXml;
     this.menuName = menuName;
     init(menuName, hori);
 }
コード例 #3
0
ファイル: Physics.cs プロジェクト: chrwoizi/canyonshooter
        public Physics(ICanyonShooterGame game, bool multiThreading)
            : base(game as Game)
        {
            this.game = game;

            Simulator.CreateMethod = OdeSimulator.CreateOdeSimulator;
            simulator             = Simulator.Create(); // Simulator erzeugen;
            simulator.StepSize    = 0.012f;             // 0.0167f ~ 60 Hz physics update rate.
            simulator.MaxContacts = 4;

            UpdateOrder = int.MaxValue - 10;

            SetupContactGroups();

            this.multiThreading = multiThreading;

            if (multiThreading)
            {
                createdObjects   = new LockingQueue <IPhysicsObject>();
                destroyedObjects = new LockingQueue <IPhysicsObject>();

                thread          = new Thread(RunMultiThreaded);
                thread.Priority = ThreadPriority.Highest;
                thread.Start();
            }
            else
            {
                createdObjects   = new NonLockingQueue <IPhysicsObject>();
                destroyedObjects = new NonLockingQueue <IPhysicsObject>();
            }
        }
コード例 #4
0
ファイル: TowerAI.cs プロジェクト: chrwoizi/canyonshooter
        public TowerAI(ICanyonShooterGame game, EnemyDescription desc)
            : base(game, "Enemy-TankAI")
        {
            this.game = game;
            id        = createdTanks++;

            // Set the tank model
            SetModel(desc.Model);

            LocalScale    = new Vector3(4f, 4f, 4f);
            LocalPosition = desc.RelativeSpawnLocation;
            dir           = new Vector3(0, 0, -1);

            // Physics Config
            ConnectedToXpa = true;
            this.Static    = true;
            ContactGroup   = ContactGroup.Enemies;
            LocalPosition  = desc.RelativeSpawnLocation;

            // Initialize AI-States of TowerAI
            AIStates = new AIStateMachine(game, this);
            AIStates.AddState(new TowerAIObserving(game.World.Players[0]));
            AIStates.AddState(new TowerAIAttackPlayer(game.World.Players[0]));
            AIStates.DebugAI = false;
        }
コード例 #5
0
 public Sunlight(ICanyonShooterGame game, Color color, Vector3 direction)
     : base(game as Game)
 {
     this.game      = game;
     this.color     = color;
     this.direction = direction;
 }
コード例 #6
0
        public BasicProjectile(ICanyonShooterGame game, Vector3 startPos, Vector3 direction, string soundName, WeaponHolderType weaponHolderType)
            : base(game)
        {
            if (game != null)
            {
                this.game = game;
            }
            else
            {
                throw new Exception("game can't be null!");
            }

            ConnectedToXpa = true;
            if (weaponHolderType == WeaponHolderType.Player)
            {
                ContactGroup = ContactGroup.PlayerProjectiles;
            }
            if (weaponHolderType == WeaponHolderType.Enemy)
            {
                ContactGroup = ContactGroup.EnemyProjectiles;
            }

            Direction = direction;

            LocalPosition = startPos;
            FromPosition  = startPos;

            if (soundName != String.Empty || soundName != "")
            {
                sound = game.Sounds.CreateSound(soundName);
                sound.Play();
            }
        }
コード例 #7
0
ファイル: Intro.cs プロジェクト: chrwoizi/canyonshooter
 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="game">game is the Canyonshootergame</param>
 public Intro(ICanyonShooterGame game)
     : base(game as Game)
 {
     this.game    = game;
     this.Visible = true;
     introtext    = game.Content.Load <IntroDescription>("Content\\Intro\\Intro");
 }
コード例 #8
0
ファイル: Listbox.cs プロジェクト: chrwoizi/canyonshooter
 public void LoadContent(ICanyonShooterGame game)
 {
     font        = game.Content.Load <SpriteFont>("Arial");
     header      = game.Content.Load <Texture2D>("Content\\Textures\\Menu\\listboxheader");
     leftside    = game.Content.Load <Texture2D>("Content\\Textures\\Menu\\listboxleft");
     rightside   = game.Content.Load <Texture2D>("Content\\Textures\\Menu\\listboxright");
     background  = game.Content.Load <Texture2D>("Content\\Textures\\Menu\\listboxback");
     statusrow   = game.Content.Load <Texture2D>("Content\\Textures\\Menu\\listboxstatus");
     buttonsback = game.Content.Load <Texture2D>("Content\\Textures\\Menu\\buttonback");
     if (scrollable)
     {
         scrollbar.LoadContent();
     }
     List.LoadContent();
     Buttons.LoadContent();
     foreach (Button i in this.List)
     {
         if (SlideBars != null)
         {
             if (SlideBars.ContainsKey(i.getButtonName()))
             {
                 SlideBars[i.getButtonName()].LoadContent();
             }
         }
     }
 }
コード例 #9
0
        public DebrisEmitter(ICanyonShooterGame game, string modelName, int maxInstanceCount, float minSize, float maxSize) : base(game, "debris emitter")
        {
            this.game      = game;
            this.modelName = modelName;
            this.minSize   = minSize;
            this.maxSize   = maxSize;

            if (maxInstanceCount > 50)
            {
                throw new Exception("Constants instancing doesn't support more than 50 instances.");
            }

            instanceData = new Matrix[maxInstanceCount];
            instances    = new ITransformable[maxInstanceCount];
            for (int i = 0; i < maxInstanceCount; i++)
            {
                instanceData[i] = Matrix.Identity;
                instances[i]    = null;
            }

            Type = new DebrisEmitterTypeSphere(game, 100, 200);

            if (game.Graphics.Device != null)
            {
                LoadContent();
            }
        }
コード例 #10
0
        /// <summary>
        /// loads this from a hud description file
        /// </summary>
        /// <param name="name">Which Hud file to load from.</param>
        public Hud(ICanyonShooterGame game, string name)
            : base(game as Game)
        {
            this.game = game;

            this.DrawOrder = (int)DrawOrderType.Hud;
        }
コード例 #11
0
ファイル: Highscores.cs プロジェクト: chrwoizi/canyonshooter
 public bool AddScore(Score score, ICanyonShooterGame game, int difficulty, bool newnames)
 {
     //this.LoadFromFile();
     if (highscores[difficulty].Count < MAX_COUNT)
     {
         if (newnames)
         {
             score.Playername = game.GameStates.Profil.CurrentProfil.Playername;
         }
         highscores[difficulty].Add(score);
         SortList(difficulty);
     }
     else
     {
         if (score.Highscore > highscores[difficulty][highscores[difficulty].Count - 1].Highscore)
         {
             if (newnames)
             {
                 score.Playername = game.GameStates.Profil.CurrentProfil.Playername; ////ABÄNDERN
             }
             highscores[difficulty].Add(score);
             SortList(difficulty);
             highscores[difficulty].RemoveAt(highscores.Count - 1);
         }
         else
         {
             return(false);
         }
     }
     return(this.SaveToFile());
 }
コード例 #12
0
 public HudBarControl(string name, GameTime gameTime, ICanyonShooterGame game, String text, SpriteFont font, String background, Vector2 pos, Vector2 size, float timeToLive, Anchor anchor, HUDEffectType effect)
     : base(name, gameTime, pos, pos, timeToLive, anchor, effect)
 {
     tc    = new HudTextControl(name + "_text", gameTime, text, font, new Color(), pos, timeToLive, anchor, effect);
     sc    = new HudSpriteControl(name + "_sprite", gameTime, game, size, background, pos, timeToLive, anchor, effect);
     Value = 100;
 }
コード例 #13
0
ファイル: Ghost.cs プロジェクト: chrwoizi/canyonshooter
 private void SetCamera(ICanyonShooterGame game)
 {
     cam               = new PerspectiveCamera(game);
     cam.Parent        = this;
     cam.LocalPosition = new Vector3(0, 9, 24);
     cam.Fov           = 90;
 }
コード例 #14
0
ファイル: Item.cs プロジェクト: chrwoizi/canyonshooter
        /// <summary>
        /// Initializes a new instance of the <see cref="Item"/> class.
        /// </summary>
        /// <param name="game">The game.</param>
        /// <param name="itemDescription">The item description.</param>
        public Item(ICanyonShooterGame game, string itemDescription)
            : base(game, itemDescription)
        {
            this.game = game;
            // Load Weapon Description
            desc = game.Content.Load <ItemDescription>("Content\\Items\\" + itemDescription);

            switch (desc.NameValue)
            {
            case "HEALTH": SetModel("item_health"); break;

            case "SHIELD": SetModel("item_shield"); break;

            default: SetModel("item_health"); break;
            }

            LocalScale = new Vector3(20, 20, 20);

            ConnectedToXpa      = true;
            ContactGroup        = ContactGroup.Items;
            InfluencedByGravity = false;


            TimeLiving = 0;

            if (game.Graphics.ShadowMappingSupported)
            {
                game.World.Sky.Sunlight.ShadowMapLow.Scene.AddDrawable(this);
                game.World.Sky.Sunlight.ShadowMapHigh.Scene.AddDrawable(this);
            }
        }
コード例 #15
0
        public StaticObject(ICanyonShooterGame game, StaticObjectDescription desc)
            : base(game, desc.Name)
        {
            this.game = game;
            StaticDescription sd = game.Content.Load <StaticDescription>("Content/Statics/" + desc.Name);

            SetModel(sd.Model);

            //TODO: Implement Position relative to canyon from XML Config (additive)
            DataLayer.Level.LevelCache c = game.World.Level.Cache[desc.SegmentId];
            ContactGroup = Engine.Physics.ContactGroup.Statics;

            CanyonSegment = desc.SegmentId;
            // Get the position from current canyon segment
            LocalPosition = game.World.Level.Cache[desc.SegmentId].APos + sd.Position;
            Vector3 canyonDir = game.World.Level.Cache[desc.SegmentId].ADir;

            canyonDir.Normalize();

            // Rotate the player to zero
            LocalRotation = Quaternion.Identity;
            LocalRotation = Helper.RotateTo(canyonDir, new Vector3(0, 0, -100));
            //Velocity = Vector3.Zero;
            if (game.Graphics.ShadowMappingSupported)
            {
                game.World.Sky.Sunlight.ShadowMapLow.Scene.AddDrawable(this);
                game.World.Sky.Sunlight.ShadowMapHigh.Scene.AddDrawable(this);
            }
        }
コード例 #16
0
        public RenderTarget2DAdapter(ICanyonShooterGame game, int width, int height, int numberLevels, SurfaceFormat format, RenderTargetUsage usage, DepthFormat depthFormat)
        {
            this.game = game;
            CreateRenderTarget(format, width, height, numberLevels, usage);

            depthStencilBuffer = new DepthStencilBuffer(game.Graphics.Device, width, height, depthFormat, MultiSampleType.None, 0);
        }
コード例 #17
0
 /// <summary>
 /// Constructor of the Modelchooser
 /// </summary>
 public Chooser(ICanyonShooterGame game)
     : base(game as Game)
 {
     this.game     = game;
     this.Visible  = true;
     modelRotation = new Vector2(0, 0);
 }
コード例 #18
0
        /// <summary>
        /// Constructor for Including Score
        ///
        /// </summary>
        public Menu(ICanyonShooterGame game, string name, bool score)
            : base(game as Game)
        {
            assetName        = "Config\\" + name + ".xml";
            this.game        = game;
            this.currentMenu = name;
            menuXml          = game.Content.Load <MenuDescription>("Content\\Menu\\" + name);
            this.visible     = true;
            this.isActive    = true;

            steuerung = new MenuControl(this, game);

            //Erstellung des Hauptmenüs
            MainList Menu = new MainList(game, name, menuXml, true);

            CurrentList  = Menu;
            shifts       = Menu;
            this.scoring = score;
            if (score)
            {
                this.startscoring = true;
                this.score        = game.GameStates.Score;
            }

            this.DrawOrder = (int)DrawOrderType.Menu;
        }
コード例 #19
0
 public PointLight(ICanyonShooterGame game, float r, float g, float b)
     : base(game as Game)
 {
     transformable = new Transformable(game, this, null);
     this.game     = game;
     color         = new Color(new Vector3(r, g, b));
 }
コード例 #20
0
ファイル: Graphics.cs プロジェクト: chrwoizi/canyonshooter
 private void InitializeShaderSelector(ICanyonShooterGame game)
 {
     // initialize shader selector
     shaderSelector = new ShaderSelector(game);
     shaderSelector.RegisterEffect("Color");
     shaderSelector.RegisterEffect("ColorConstantsInstancing");
     shaderSelector.RegisterEffect("ColorHardwareInstancing");
     shaderSelector.RegisterEffect("Depth");
     shaderSelector.RegisterEffect("DepthConstantsInstancing");
     shaderSelector.RegisterEffect("DepthHardwareInstancing");
     shaderSelector.RegisterEffect("Light");
     shaderSelector.RegisterEffect("LightConstantsInstancing");
     shaderSelector.RegisterEffect("LightHardwareInstancing");
     shaderSelector.RegisterEffect("Shadow");
     shaderSelector.RegisterEffect("ShadowConstantsInstancing");
     shaderSelector.RegisterEffect("ShadowHardwareInstancing");
     shaderSelector.RegisterEffect("Texture");
     shaderSelector.RegisterEffect("TextureConstantsInstancing");
     shaderSelector.RegisterEffect("TextureHardwareInstancing");
     shaderSelector.RegisterEffect("Wireframe");
     shaderSelector.RegisterEffect("WireframeConstantsInstancing");
     shaderSelector.RegisterEffect("WireframeHardwareInstancing");
     shaderSelector.RegisterEffect("NormalMapping");
     shaderSelector.InitializeDepthShaders();
 }
コード例 #21
0
        /// <summary>
        /// Initializes a new instance of the <see cref="WaypointObject"/> class.
        /// </summary>
        /// <param name="game">The game.</param>
        /// <param name="desc">The desc.</param>
        public WaypointObject(ICanyonShooterGame game, WaypointObjectDescription desc)
            : base(game, "Waypoint")
        {
            this.game      = game;
            ConnectedToXpa = true;
            Static         = true;
            SetModel(desc.Model);

            //game.GameStates.Profil.
            secondsToAdd  = desc.TimeInSeconds;
            CanyonSegment = desc.SegmentId;
            DataLayer.Level.LevelCache c = game.World.Level.Cache[desc.SegmentId];
            //Vector3 canyonPosition = new Vector3(c.APosX, c.APosY, c.APosZ);
            //Quaternion rotation = Helper.RotateTo(game.World.Level.Cache[desc.SegmentId].ADir, -Vector3.UnitZ);
            //LocalPosition = Vector3.Transform(desc.RelativeSpawnLocation, rotation) + canyonPosition;
            ContactGroup = Engine.Physics.ContactGroup.Waypoint;
            // Get the position from current canyon segment
            LocalPosition = game.World.Level.Cache[desc.SegmentId].APos;
            Vector3 canyonDir = game.World.Level.Cache[desc.SegmentId].ADir;

            canyonDir.Normalize();

            // Rotate the player to zero
            LocalRotation = Quaternion.Identity;
            LocalRotation = Helper.RotateTo(canyonDir, new Vector3(0, 0, -100));
            //Velocity = Vector3.Zero;



            if (game.Graphics.ShadowMappingSupported)
            {
                game.World.Sky.Sunlight.ShadowMapLow.Scene.AddDrawable(this);
                game.World.Sky.Sunlight.ShadowMapHigh.Scene.AddDrawable(this);
            }
        }
コード例 #22
0
 public PointLight(ICanyonShooterGame game, Color color)
     : base(game as Game)
 {
     transformable = new Transformable(game, this, null);
     this.game     = game;
     this.color    = color;
 }
コード例 #23
0
 public Finish(ICanyonShooterGame game)
     : base(game, "Final")
 {
     this.game = game;
     SetModel("Final");
     LocalScale = new Vector3(10, 10, 10);
 }
コード例 #24
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="game"></param>
        /// <param name="direction"></param>
        /// <param name="angle">half opening angle in degrees (180 -> sphere)</param>
        /// <param name="minVelocity"></param>
        /// <param name="maxVelocity"></param>
        public DebrisEmitterTypeCone(ICanyonShooterGame game, Vector3 direction, float angle, float minVelocity, float maxVelocity)
            : base(game)
        {
            Debug.Assert(!float.IsNaN(direction.X));

            this.direction       = direction;
            this.angleAsRadiants = MathHelper.ToRadians(angle);
            this.minVelocity     = minVelocity;
            this.maxVelocity     = maxVelocity;

            // compute a vector which is perpendicular to direction
            // find a direction which is NOT nearly colinear to direction (otherwise cross product will be too small)
            if (Math.Abs(Vector3.Dot(direction, new Vector3(1, 0, 0))) < 0.9f)
            {
                // use vector 1,0,0
                perpendicularDirection = Vector3.Cross(direction, new Vector3(1, 0, 0));
            }
            else
            {
                // use vector 0,1,0
                perpendicularDirection = Vector3.Cross(direction, new Vector3(0, 1, 0));
            }

            direction.Normalize();
            perpendicularDirection.Normalize();
        }
コード例 #25
0
ファイル: Ghost.cs プロジェクト: chrwoizi/canyonshooter
        /// <summary>
        /// Ordinary constructor.
        /// </summary>
        /// <param name="game">The main CanyonShooter game object</param>
        public Ghost(ICanyonShooterGame game)
            : base(game, "PlayerElcode")
        {
            EnabledChanged += (Player2_EnabledChanged);

            // Set player profile values
            SetModel(game.GameStates.Profil.CurrentProfil.Model);
            BankingFactor  = game.GameStates.Profil.CurrentProfil.Banking;
            DriftFactor    = game.GameStates.Profil.CurrentProfil.Drift;
            TranslationGap = game.GameStates.Profil.CurrentProfil.Translation;
            RollFactor     = game.GameStates.Profil.CurrentProfil.Rolling;
            MaxDecay       = game.GameStates.Profil.CurrentProfil.Brake;
            AutoLevel      = game.GameStates.Profil.CurrentProfil.AutoLevel;
            Health         = game.GameStates.Profil.CurrentProfil.Health;
            MinSpeed       = game.GameStates.Profil.CurrentProfil.Speed;
            Shield         = game.GameStates.Profil.CurrentProfil.Shield;
            SpeedGap       = game.GameStates.Profil.CurrentProfil.Acceleration;

            // Initialize player environment
            LocalPosition       = new Vector3(0, 0, 0);
            ConnectedToXpa      = true;
            ContactGroup        = ContactGroup.None;
            InfluencedByGravity = false;
            this.game           = game;
            //SetCamera(game);

            // Set sound listener for 3D sound
            listener = new SoundListener(game);
            game.Sounds.SoundListener = listener;
        }
コード例 #26
0
 public OrthographicCamera(ICanyonShooterGame game, int width, int height)
     : base(game)
 {
     this.width  = width;
     this.height = height;
     MakeProjectionMatrix();
 }
コード例 #27
0
ファイル: Profil.cs プロジェクト: chrwoizi/canyonshooter
        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="game">current Canyonshootergame</param>
        public Profil(ICanyonShooterGame game)
            : base(game as Game)
        {
            this.game = game;
            question  = false;

            BildXml                  = game.Content.Load <ProfilDescription>("Content\\Profil\\" + "Profil");
            ProfilXml                = new List <ProfilProperties>();
            GrafikList               = new Dictionary <string, object>();
            SoundList                = new Dictionary <string, object>();
            SteuerungList            = new Dictionary <string, object>();
            SpielereinstellungenList = new Dictionary <string, object>();

            grafikDat                     = new Dictionary <string, string>();
            soundDat                      = new Dictionary <string, string>();
            steuerungDat                  = new Dictionary <string, string>();
            spielereinstellungenDat       = new Dictionary <string, string>();
            namenKeysSound                = new List <string>();
            namenKeysGrafik               = new List <string>();
            namenKeysSteuerung            = new List <string>();
            namenKeysSpielereinstellungen = new List <string>();

            this.Visible = true;

            steuerung = new ProfilControl(this, game);

            CurrentList = new ButtonList(game, BildXml);

            counter = 0;
        }
コード例 #28
0
ファイル: HSlideBar.cs プロジェクト: chrwoizi/canyonshooter
        // Konstuktor
        // Dieser Konstruktor kann von außen nicht erreicht werden.
        public HSlideBar(ICanyonShooterGame game, Button but, Vector2 pos, float minValue, float maxValue, float Startvalue,
                         float stepSize, int faktor, int cut)
            : base(game as Game)
        {
            this.game                   = game;
            this.caller                 = but;
            this.StartPosition          = pos;
            this.factor                 = faktor;
            this.currentValue           = Startvalue;
            this.maxValue               = maxValue;
            this.minValue               = minValue;
            this.stepSize               = stepSize;
            this.ButtonHeightForContent = (int)Math.Ceiling((double)(but.Height - 8));
            this.cut = cut;


            this.minus = new Button(game, "Minus", calculateRectangle(new Vector2(StartPosition.X,
                                                                                  StartPosition.Y + 4), ButtonHeightForContent,
                                                                      ButtonHeightForContent), MinusImage, true, this);
            minus.Buttonpressed += new ActionEventHandler(MinusPressed);

            this.BarPosition     = new Vector2(minus.Position.Right, minus.Position.Top + (minus.Position.Height / 2) - (BarHeight / 2)) + ButtonOffset;
            this.minPushPosition = this.BarPosition + new Vector2(6, 0);
            this.maxPushPosition = this.BarPosition + new Vector2(BarWidth - 6 - makerwidth, 0);
            this.PushLenght      = maxPushPosition.X - minPushPosition.X;
            Vector2 pluspos = new Vector2(this.BarPosition.X + BarWidth, this.minus.Position.Y) + ButtonOffset;

            this.plus = new Button(game, "Plus", calculateRectangle(pluspos, ButtonHeightForContent,
                                                                    ButtonHeightForContent), PlusImage, true, this);
            plus.Buttonpressed += new ActionEventHandler(PlusPressed);

            calculatingMakerPos(Startvalue);
            barRec = calculateRectangle(new Vector2(this.BarPosition.X, BarPosition.Y - 5), 27, (int)(BarPosition.X + (int)(BarWidth - 6 - makerwidth)) - (int)(BarPosition.X + 6) + 19);
        }
コード例 #29
0
ファイル: Dialog.cs プロジェクト: chrwoizi/canyonshooter
        public Dialog(ICanyonShooterGame game, OptionDescription xml, int district,
                      Dictionary <string, object> Data, Dictionary <string, string> Format, List <string> Names)
            : base(game as Game)
        {
            this.game     = game;
            this.xml      = xml;
            this.Data     = Data;
            this.Format   = Format;
            this.Names    = Names;
            this.district = district;
            this.visible  = true;
            this.list     = new OptionList(game, xml, district, Data, Format, Names, false, this);

            OptMod   = new Dictionary <string, OptionModulationButton>();
            SlideMod = new Dictionary <string, HSlideBar>();
            int counter = Names.Count;

            foreach (Button g in this.list)
            {
                OptionModulationButton opt = getOptionModulationButton(g, Names[Names.Count - counter]);
                if (opt != null)
                {
                    OptMod.Add(g.getButtonName(), opt);
                }
                else
                {
                    HSlideBar hsb = getSlideBar(g, Names[Names.Count - counter]);
                    if (hsb != null)
                    {
                        SlideMod.Add(g.getButtonName(), hsb);
                    }
                }
                counter--;
            }

            foreach (OptionpartDescription i in xml.OptionParts)
            {
                if (i.Number == this.district)
                {
                    this.Position = new Rectangle(game.Graphics.Device.Viewport.Width - 398 + (i.Position.X - 398),
                                                  i.Position.Y, i.Position.Width, list.Height + i.Position.Height);
                    this.startposition = new Vector2(game.Graphics.Device.Viewport.Width - 398 + (i.StartPosition.X - 398),
                                                     i.StartPosition.Y);
                    foreach (OptionButtonDescription g in i.Buttons)
                    {
                        if (g.ButtonName == "Akzeptieren")
                        {
                            accept = new Button(game, g.ButtonName, startposition, g.height, g.width,
                                                "OptionDialog\\" + g.ButtonImage, true, this);
                        }
                        else if (g.ButtonName == "Ablehnen")
                        {
                            decline = new Button(game, g.ButtonName, startposition, g.height, g.width,
                                                 "OptionDialog\\" + g.ButtonImage, true, this);
                        }
                    }
                }
            }
        }
コード例 #30
0
ファイル: Listbox.cs プロジェクト: chrwoizi/canyonshooter
        public Listbox(ICanyonShooterGame game, Vector2 pos, bool scroll, MenuDescription xml, int district, Dictionary <string, object> Data, Dictionary <string, string> Format, List <string> Names)
            : base(district)
        {
            this.isActive = true;
            this.visible  = true;
            this.game     = game;
            this.style    = 1;

            this.Position   = pos;
            this.scrollable = scroll;

            this.data = Data;

            this.BoxContentPosition = new Vector2(Position.X + 7, Position.Y + 30);
            this.BoxContentHeight   = this.BoxHeight - 30 - 31;
            this.Titel = "Optionen: ";

            switch (difficulty)
            {
            case 0:
                this.Titel += "Spielereinstellungen";
                break;

            case 1:
                this.Titel += "Grafik";
                break;

            case 2:
                this.Titel += "Sound";
                break;

            case 3:
                this.Titel += "Steuerung";
                break;

            default:
                break;
            }

            //Building the Member for the Buttons and Scores
            this.List    = new OptionList(game, game.Content.Load <OptionDescription>("Content\\Menu\\OptionMenu"), district, BoxContentPosition, Data, Format, Names, false, this);
            this.Buttons = new NormalList(game, ButtonPosition(xml), "OptionList", xml, true);
            this.Scrolling();
            this.intializeScrollbar();

            slideBars = new Dictionary <string, HSlideBar>();
            int counter = Names.Count;

            foreach (Button g in this.List)
            {
                HSlideBar hsb = getSlideBar(g, Names[Names.Count - counter]);
                if (hsb != null)
                {
                    slideBars.Add(g.getButtonName(), hsb);
                }

                counter--;
            }
        }