Пример #1
0
        // build this object
        public void Update(GameTime gametime,Cursor cursor,Scientist scientist, Assistant assistant, List<MiniProgressBar> bars, Build build, List<FloorObject> floorObjectList, ReachableArea reachable, NumericalCounter money)
        {
            // check for mouseover/click on machine

            mouseOver = false;

            if (cursor.position.X >= (position.X - offset.X) && cursor.position.X <= (position.X - offset.X + ((rect.Width * scale) / frames))
                    && cursor.position.Y >= position.Y - offset.Y && cursor.position.Y <= (position.Y - offset.Y + (rect.Height * scale))
                        && cursor.corpseMouseover == false && menu == false && menuActions.Count > 0 && build.menu == false)
            {
                    // turn on menu when object is clicked

                if (cursor.mouseState.LeftButton == ButtonState.Pressed | cursor.mouseState.RightButton == ButtonState.Pressed)
                    {
                        if (cursor.click == false)
                        {
                            menu = true;
                            menuStart = true;
                            menuPosition = cursor.position;
                            cursor.click = true;
                        }
                    }

                    if (menu == false && mouseOver == false && cursor.mouseOver == false)
                    {
                        cursor.menuObject = this;
                        mouseOver = true; // add object mouseover text if no menu
                        cursor.mouseOver = true;
                    }

            }

            // check for mouseover/click on build menu icon

            iconMouseover = false;
            badIconMouseover = false;

            if (onBuildList == true)
            {
                if (cursor.position.X >= iconPosition.X && cursor.position.X <= iconPosition.X + iconTex.Width
                       && cursor.position.Y >= iconPosition.Y && cursor.position.Y <= iconPosition.Y + iconTex.Height && cursor.buildIconMouseover == false)
                {

                    iconMouseover = true;
                    cursor.buildIconMouseover = true;
                    cursor.menuObject = this;

                    // build object is clicked

                    if (cursor.mouseState.LeftButton == ButtonState.Pressed | cursor.mouseState.RightButton == ButtonState.Pressed)
                    {
                        if (cursor.click == false)
                        {
                            if (money.value >= this.cost)
                            {
                                money.value -= this.cost;
                                build.BuildThis(floorObjectList, this, reachable);
                                cursor.click = true;
                            }

                            else
                            {
                                iconMouseover = false;
                                badIconMouseover = true;
                            }
                        }
                    }

                }
            }

            // animation
            timer += gametime.ElapsedGameTime.Milliseconds;

            if (on == true)
            {
                currentAnim = 1;
            }
            else
            {
                currentAnim = 0;
            }

            if (timer >= frate)
            {
                timer = 0;

                if (currentFrame++ == frames - 1)
                {
                    currentFrame = 0;
                }

                rect.X = currentFrame * width;
                rect.Y = currentAnim * height;
            }

            // set menu dimensions, make list of names and colours for each object

            if (menu == true && menuStart == true)
            {

                // find longest string in menu

                int boxWidth = 0;
                actions = new List<Tuple<string, Color, Color, Color>> { };

                    foreach (MenuAction action in menuActions)
                    {
                        // add
                        actions.Add(new Tuple<string, Color, Color, Color> ( action.name, Color.White, Color.Gray, Color.DarkGray ) );

                        if (action.name.Length > boxWidth)
                        {
                            boxWidth = action.name.Length; // set box width for below

                        }
                    }

                // boxes and outlines

                menuRectangle.Width = boxWidth * 12 + 10;  // set width to widest text from above
                menuRectangle.Height = 30;                  // menu item height spread
            }

            // menu update

            if (menu == true)
            {
                menuMouseover = false;

                Vector2 menuItemPosition = menuPosition;

                foreach (MenuAction action in menuActions)
                {

                    // IF MOUSE-OVERED change colours, set to highlighted item

                    if (cursor.position.X >= menuItemPosition.X && cursor.position.X < (menuItemPosition.X + menuRectangle.Width) && cursor.position.Y >= menuItemPosition.Y && cursor.position.Y < (menuItemPosition.Y + menuRectangle.Height))
                    {
                        textColour = Color.Black;
                        boxColour = Color.LightGray;
                        lineColour = Color.LimeGreen;

                        menuHighlightAction = action;
                        menuMouseover = true;

                        if (cursor.mouseState.LeftButton == ButtonState.Pressed | cursor.mouseState.RightButton == ButtonState.Pressed)
                        {
                            if (cursor.click == false)
                            {
                                    if (action.scientist == true)
                                    {
                                        if (scientist.walking == true)
                                        {
                                            scientist.walking = false;
                                            scientist.floorObject = null;
                                            scientist.action = null;
                                        }

                                        else if (scientist.doing == true)
                                        {
                                            scientist.doing = false;
                                            scientist.corpseWork = false;
                                            scientist.floorObject = null;
                                            bars.Remove(scientist.progBar);
                                            scientist.action = null;
                                            scientist.animStart = true;
                                        }

                                        scientist.action = menuHighlightAction;
                                        scientist.floorObject = this;
                                    }

                                    if (action.assistant == true && assistant.outside == false && assistant.corpseCarrying == false)
                                    {
                                        if (assistant.walking == true)
                                        {
                                            assistant.walking = false;
                                            assistant.floorObject = null;
                                            assistant.action = null;
                                        }

                                        else if (assistant.doing == true)
                                        {
                                            assistant.doing = false;
                                            assistant.digging = false;
                                            assistant.floorObject = null;
                                            bars.Remove(assistant.progBar);
                                            assistant.action = null;
                                            assistant.animStart = true;
                                        }

                                        assistant.action = menuHighlightAction;
                                        assistant.floorObject = this;
                                    }

                                    // both using same machine?
                                    if (action.assistant == true && action.scientist == true)
                                    {
                                        assistant.twoWork = true;
                                    }

                                menu = false;

                            }

                            cursor.click = true;
                        }
                    }

                    else
                    {
                        textColour = Color.White;
                        boxColour = Color.Gray;
                        lineColour = Color.DarkGray;

                        if (cursor.mouseState.LeftButton == ButtonState.Pressed | cursor.mouseState.RightButton == ButtonState.Pressed)
                        {
                            if (cursor.click == false)
                            {
                                menu = false;
                            }
                        }
                    }

                    int index = menuActions.IndexOf(action);
                    actions[index] = new Tuple<string, Color, Color, Color>(actions[index].Item1, textColour, boxColour, lineColour);

                    menuItemPosition = menuItemPosition + new Vector2(0, menuRectangle.Height);

                }
            }
        }
Пример #2
0
        // === load things... ==============
        protected override void LoadContent()
        {
            //========== GRAPHICS ==============================================

            // set viewport to size of screen, dependant on fullscreen/windowed
            if (graphics.IsFullScreen == true)
            {
                GraphicsDevice.Viewport = new Viewport(0, 0, GraphicsAdapter.DefaultAdapter.CurrentDisplayMode.Width,
                                                GraphicsAdapter.DefaultAdapter.CurrentDisplayMode.Height);
            }
            else
            {
                GraphicsDevice.Viewport = new Viewport(0, 0, Screen.PrimaryScreen.WorkingArea.Width - borderSpace,
                                                                Screen.PrimaryScreen.WorkingArea.Height - SystemInformation.CaptionHeight - borderSpace);
            }

            // find maximum size of render field with 16:9 aspect ratio when full screen

            width = GraphicsAdapter.DefaultAdapter.CurrentDisplayMode.Width;
            height = (int)(width / aspectRatio);

            if (height > GraphicsAdapter.DefaultAdapter.CurrentDisplayMode.Height)
            {
                height = GraphicsAdapter.DefaultAdapter.CurrentDisplayMode.Height;
                width = (int)(height * aspectRatio);
            }

            xScale = (float)((double)width / (double)targetWidth);
            yScale = (float)((double)height / (double)targetHeight);

            xOffset = (int)((GraphicsAdapter.DefaultAdapter.CurrentDisplayMode.Width - width) / 2.0);
            yOffset = (int)((GraphicsAdapter.DefaultAdapter.CurrentDisplayMode.Height - height) / 2.0);

            // find maximum size of render field with 16:9 aspect ratio when windowed

            wheight = Screen.PrimaryScreen.WorkingArea.Height - SystemInformation.CaptionHeight - borderSpace;
            wwidth = (int)(wheight * aspectRatio);

            if (wwidth > Screen.PrimaryScreen.WorkingArea.Width - borderSpace)
            {
                wwidth = Screen.PrimaryScreen.WorkingArea.Width - borderSpace;
                wheight = (int)(wwidth / aspectRatio);
            }

            wxScale = (float)((double)wwidth / (double)targetWidth);
            wyScale = (float)((double)wheight / (double)targetHeight);

            wxOffset = (int)((Screen.PrimaryScreen.WorkingArea.Width - borderSpace - wwidth) / 2.0);
            wyOffset = (int)((Screen.PrimaryScreen.WorkingArea.Height - SystemInformation.CaptionHeight - borderSpace - wheight) / 2.0);

            // set viewport to this maximum render size, dependent on fullscreen/windowed
            if (graphics.IsFullScreen == true)
            {
                GraphicsDevice.Viewport = new Viewport(xOffset, yOffset, width, height);
            }

            if (graphics.IsFullScreen == false)
            {
                GraphicsDevice.Viewport = new Viewport(wxOffset, wyOffset, wwidth, wheight);

                var form = (System.Windows.Forms.Form)System.Windows.Forms.Control.FromHandle(this.Window.Handle);
                form.Location = new System.Drawing.Point(0, 0);
            }

            // spritebatch

            spriteBatch = new SpriteBatch(GraphicsDevice);

            // ========= GAME OBJECTS ================================================

            // fonts

            cursorFont = Content.Load<SpriteFont>("font");
            counterFont = Content.Load<SpriteFont>("font2");

            // grid

            grid = new Grid(3600, 1750, 450, 20, 20, new Vector2(-850, 1070), true);
            reachable = new ReachableArea(grid, floorObjectList);

            // counters
            research = new NumericalCounter("Research", new Vector2(25, 15), 0, 100, 0, 0, counterFont, Color.Green, Color.Green, Content.Load<Texture2D>("counter_box"));
            madness = new NumericalCounter("Madness", new Vector2(25, 85), 0, 0, 0, 0, counterFont, Color.Red, Color.Green, Content.Load<Texture2D>("counter_box"));
            money = new NumericalCounter("Money", new Vector2(25, 155), 0, 500, 0, 60, counterFont, Color.Orange, Color.Yellow, Content.Load<Texture2D>("counter_box"), true);
            papers = new NumericalCounter("Papers Published", new Vector2(10, 300), 0, 0, 0, 0, cursorFont, Color.Black, Color.Black);
            lifeForce = new NumericalCounter("Life Force", new Vector2(10, 320), 100, 100, 0, 0, cursorFont, Color.Black, Color.Black);
            longevity = new NumericalCounter("Longevity", new Vector2(10, 340), 100, 30, 0, 0, cursorFont, Color.Black, Color.Black);
            humanity = new NumericalCounter("Humanity", new Vector2(10, 360), 100, 30, 0, 0, cursorFont, Color.Black, Color.Black);

            counters = new List<NumericalCounter>{research,madness,money,papers,lifeForce,longevity,humanity};

            build = new Build(new Vector2(5, 900), Content.Load<Texture2D>("build_icon_standard"), Content.Load<Texture2D>("build_icon_highlight"), Content.Load<Texture2D>("build_icon_pressed"), Content.Load<Texture2D>("invarrow"), Content.Load<Texture2D>("highinvarrow"), GraphicsDevice);

            //=====================================================

            // load menu actions from XML
            System.IO.Stream stream = TitleContainer.OpenStream("XMLActions.xml");

            XDocument doc = XDocument.Load(stream);

            menuActions = (from action in doc.Descendants("menuAction")
                           select new MenuAction(
                                                           action.Element("name").Value,
                                                           Convert.ToBoolean(action.Element("scientist").Value),
                                                           Convert.ToBoolean(action.Element("assistant").Value),
                                                           Convert.ToInt32(action.Element("time").Value),
                                                           (float)Convert.ToDouble(action.Element("reasearchUp").Value),
                                                           (float)Convert.ToDouble(action.Element("madnessUp").Value),
                                                           (float)Convert.ToDouble(action.Element("moneyChange").Value),
                                                           (float)Convert.ToDouble(action.Element("lifeForceUp").Value),
                                                           (float)Convert.ToDouble(action.Element("longevityUp").Value),
                                                           (float)Convert.ToDouble(action.Element("humanityUp").Value),
                                                           Convert.ToBoolean(action.Element("remain").Value),
                                                           Convert.ToBoolean(action.Element("turnOn").Value),
                                                           Convert.ToBoolean(action.Element("turnOff").Value),
                                                           new List<NumericalCounter> { research },
                                                           (float)Convert.ToDouble(action.Element("reasearchUpMultiplier").Value),
                                                           (float)Convert.ToDouble(action.Element("madnessUpMultiplier").Value),
                                                           (float)Convert.ToDouble(action.Element("moneyChangeMultiplier").Value),
                                                           (float)Convert.ToDouble(action.Element("lifeForceUpMultiplier").Value),
                                                           (float)Convert.ToDouble(action.Element("longevityUpMultiplier").Value),
                                                           (float)Convert.ToDouble(action.Element("humanityUpMultiplier").Value)
                                                           )).ToList();

            // dependant actions

            studyLiveCorpse = menuActions[6];
            writePaper = menuActions[9];

            // independent actions
            studyCorpse = menuActions[2];
            dissectCorpse = menuActions[3];
            clearCorpse = menuActions[4];
            talk = menuActions[7];

            // load in multiplying counters

            List<Tuple<string, string, string, string>> multipliers = new List<Tuple<string, string, string, string>>();

            multipliers = (from floorObject in doc.Descendants("menuAction")
                           select new Tuple<string, string, string, string>(
                            floorObject.Element("name").Value,
                            floorObject.Element("multiplyingCounter").Value,
                            floorObject.Element("multiplyingCounter2").Value,
                            floorObject.Element("multiplyingCounter3").Value)
                               ).ToList();

            foreach (MenuAction action in menuActions)
            {
                foreach (Tuple<string, string, string, string> tuple in multipliers)
                {
                    if (tuple.Item1 == action.name)
                    {
                        foreach (NumericalCounter counter in counters)
                        {
                            foreach (string name in new List<string> { tuple.Item2, tuple.Item3, tuple.Item4 })
                            {
                                if (counter.name == name)
                                {
                                    action.dependent.Add(counter);
                                }
                            }
                        }
                    }
                }
            }

            // load floor objects from XML
            System.IO.Stream stream2 = TitleContainer.OpenStream("XMLFloorObjects.xml");

            XDocument doc2 = XDocument.Load(stream2);

            build.buildList = (from floorObject in doc2.Descendants("FloorObject") select new FloorObject(Content.Load<Texture2D>(
                                    Convert.ToString(floorObject.Element("texture").Value)),
                                    Content.Load<Texture2D>(Convert.ToString(floorObject.Element("icon").Value)),
                                    Convert.ToInt32(floorObject.Element("frameNumber").Value),
                                    Convert.ToInt32(floorObject.Element("animNumber").Value),
                                    new Vector2(Convert.ToInt32(floorObject.Element("gridPositionX").Value),Convert.ToInt32(floorObject.Element("gridPositionY").Value)), grid,
                                    floorObject.Element("name").Value,
                                    Convert.ToInt32(floorObject.Element("cost").Value),
                                    new List<MenuAction>{}, GraphicsDevice,
                                    new Vector2(Convert.ToInt32(floorObject.Element("footprintX").Value),Convert.ToInt32(floorObject.Element("footprintY").Value)),
                                    Convert.ToBoolean(floorObject.Element("prebuilt").Value))
                                    ).ToList();

            // load in menu actions

            List<Tuple<string,string,string,string>> actions = new List<Tuple<string,string,string,string>>();

            actions = (from floorObject in doc2.Descendants("FloorObject")
                           select new Tuple<string,string,string,string>(
                            floorObject.Element("name").Value,
                            floorObject.Element("menuAction").Value,
                            floorObject.Element("menuAction2").Value,
                            floorObject.Element("menuAction3").Value)
                               ).ToList();

            foreach (FloorObject machine in build.buildList)
            {
                foreach (Tuple<string,string,string,string> tuple in actions)
                {
                    if (tuple.Item1 == machine.name)
                    {
                        foreach (MenuAction action in menuActions)
                        {
                            foreach (string name in new List<string>{tuple.Item2,tuple.Item3,tuple.Item4})
                            {
                                if (action.name == name)
                                {
                                    machine.menuActions.Add(action);
                                }
                            }
                        }
                    }
                }
            }

            // build any prebuilt objects

            foreach (FloorObject machine in build.buildList)
            {
                if (machine.prebuilt == true)
                {
                    build.BuildThis(floorObjectList, machine, reachable);
                }
            }

            build.removeUpdate(money);

            // objects

            table = build.buildList[0];
            lightningAbsorber = build.buildList[1];

            resurrect = new Resurrect(new Vector2(1750, 900), Content.Load<Texture2D>("raise_icon_standard"), Content.Load<Texture2D>("raise_icon_highlight"), Content.Load<Texture2D>("raise_icon_pressed"), GraphicsDevice, table);

            //===================================================

            // background stuff

            room = new NonInteractive(Vector2.Zero, 0.6f, Content.Load<Texture2D>("room"));
            door = new NonInteractive(new Vector2(380, 200), 0.59f, Content.Load<Texture2D>("door"),2);
            graveyard = new Graveyard(new Vector2(1140,200), 0.8f, new Vector2(10,760),Content.Load<Texture2D>("back"), Content.Load<Texture2D>("dig_icon_standard"), Content.Load<Texture2D>("dig_icon_highlight"), Content.Load<Texture2D>("dig_icon_pressed"), GraphicsDevice, 0.5f);
            digger = new NonInteractive(new Vector2(1200, 300), 0.79f, Content.Load<Texture2D>("digger"), 1, 10);
            Switch = new NonInteractive(new Vector2(860,400), 0.58f, Content.Load<Texture2D>("switch"), 2, 1);

            // cursor

            cursor = new Cursor(Content.Load<Texture2D>("cursor"),GraphicsDevice);

            // characters

            Simon = new Scientist(Content.Load<Texture2D>("tmpprof"), new Vector2(10,1),grid,reachable,table);
            Jeremy = new Assistant(Content.Load<Texture2D>("tmpass"), new Vector2(8, 1), grid,reachable,table);

            // the corpse!

            corpse = new Corpse(new Vector2(725, 540),Content.Load<Texture2D>("corpse"), new List<MenuAction> { studyCorpse, dissectCorpse }, new List<MenuAction> { talk,studyLiveCorpse }, new List<MenuAction> { clearCorpse },GraphicsDevice);

            // update reachable area to account for these

            reachable.Update(floorObjectList);

            // test items...

            blob = new positionTextBlob(Content.Load<Texture2D>("gball"), new Vector2(1, 1));

            knob = new Knob(new Vector2(300, 300), 0.2f, Content.Load<Texture2D>("knob"));

            // test saving...
        }