Exemplo n.º 1
0
        public MiniProgressBar(GraphicsDevice graphicsDevice, Vector2 position, MenuAction menuAction, FloorObject machine)
        {
            dummyTexture = new Texture2D(graphicsDevice, 1, 1);
            dummyTexture.SetData(new Color[] { Color.Gray });

            box = new Rectangle();
            bar = new Rectangle();

            this.position = position;

            this.barColour = Color.LimeGreen;
            this.boxColour = Color.Gray;

            this.box.Width = width;
            this.box.Height = height;

            this.fullWidth = (int)(width - 4);

            this.bar.Height = (int)(height - 4);
            this.bar.Width = (int)(fullWidth * (value / (float)init));

            this.action = menuAction;
            this.init = action.time;
            this.value = 0;

            this.floorObject = machine;

            action.done = false;
        }
Exemplo n.º 2
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);

                }
            }
        }
Exemplo n.º 3
0
        public void Update(GameTime gametime, GraphicsDevice graphicsDevice, Cursor cursor, NumericalCounter research,NumericalCounter money, NumericalCounter madness, List<MiniProgressBar> proglist, ReachableArea reachable)
        {
            // get most recent reachable areas
            path.Update(reachable);

            // update position from grid position

            position = grid.CartesianCoords(gridPosition);

            // determine later from position and direction of movement

            if (walking == true)
            {
                layer = 0.2f + (0.2f / (float)grid.rows) * walkingTarget.Y + (0.2f / ((float)grid.columns * (float)grid.rows + 1)) * Math.Abs(walkingTarget.X - (float)grid.columns / 2.0f);
            }

            else
            {
                layer = 0.2f + (0.2f / (float)grid.rows) * gridPosition.Y + (0.2f / ((float)grid.columns * (float)grid.rows + 1)) * Math.Abs(gridPosition.X - (float)grid.columns / 2.0f);
            }

            offset = new Vector2((width * scale) / 2.0f, height * scale); // factor of 2 here and in the draw command are just for this test anim, so it's a decent size...

            // walking....

            if (action != null && walking == false && doing == false)
            {
                // to corpse
                if (corpseWork == true)
                {
                    if (gridPosition != corpsePosition)
                    {
                        walking = true;
                        drawPath = path.PathList(gridPosition, corpsePosition, grid);
                        pathStep = 1;
                        walkingTarget = drawPath[pathStep];
                    }

                    else
                    {
                        doing = true;
                        currentFrame = 0;
                        gridPosition = drawPath[pathStep - 1];
                        position = grid.CartesianCoords(gridPosition);
                    }
                }

                // to machine
                else if (gridPosition !=  floorObject.opPos)
                {
                    walking = true;
                    drawPath = path.PathList(gridPosition, floorObject.opPos, grid);
                    pathStep = 1;
                    walkingTarget = drawPath[pathStep];
                }

                // arrived at destination, start doing
                else
                {
                    doing = true;
                    currentFrame = 0;
                    gridPosition = drawPath[pathStep - 1];
                    position = grid.CartesianCoords(gridPosition);
                }
            }

            if (walking == true)
            {
                direction = (grid.CartesianCoords(walkingTarget) - grid.CartesianCoords(gridPosition));
                targetDistance = direction.Length();
                direction.Normalize();

                walkingOffset += direction * gametime.ElapsedGameTime.Milliseconds * 0.2f;
                distanceGone = walkingOffset.Length();

                if (distanceGone < targetDistance)
                {
                    Vector2 move = walkingOffset;
                    position += move;
                }

                else
                {
                    pathStep += 1;

                    if (pathStep < drawPath.Count)
                    {
                        gridPosition = drawPath[pathStep - 1];
                        walkingTarget = drawPath[pathStep];
                        position = grid.CartesianCoords(gridPosition);
                    }

                    else
                    {
                        walking = false;
                        doing = true;
                        currentFrame = 0;
                        gridPosition = drawPath[pathStep-1];
                        position = grid.CartesianCoords(gridPosition);
                    }

                    walkingOffset = Vector2.Zero;
                    targetDistance = 0;
                    distanceGone = 0;

                }
            }

            // update animation frame

            timer += gametime.ElapsedGameTime.Milliseconds;

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

                if (walking == true)
                {
                    if (Math.Abs(direction.X) >= Math.Abs(direction.Y))
                    {
                        if (direction.X >= 0)
                        {
                            anim = 1;
                        }

                        else
                        {
                            anim = 0;
                        }

                    }

                    if (Math.Abs(direction.Y) >= Math.Abs(direction.X))
                    {
                        if (direction.Y >= 0)
                        {
                            anim = 2;
                        }

                        else
                        {
                            anim = 3;
                        }
                    }

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

                // start up menu action if doing is done, animate doing
                if (doing == true)
                {
                    anim = 4;

                    if (action != null)
                    {
                        // if not staying, run anim once, start progress bar
                        if (action.remain == false)
                        {
                            if (currentFrame++ == numberOfFrames - 1)
                            {
                                doing = false;
                                proglist.Add(new MiniProgressBar(graphicsDevice, floorObject.position + new Vector2(-5, -105), action, floorObject));
                                progBar = proglist[-1];
                                action = null;

                            }
                        }

                        // if staying to work machine...
                        else
                        {
                            // if starting, create progress bar and start anim
                            if (animStart == true)
                            {
                                animStart = false;

                                if (corpseWork == true)
                                {
                                    proglist.Add(new MiniProgressBar(graphicsDevice, position + new Vector2(0, -100), action, null));
                                    progBar = proglist[proglist.Count -1];
                                }

                                else
                                {
                                    proglist.Add(new MiniProgressBar(graphicsDevice, floorObject.position + new Vector2(-5, -105), action, floorObject));
                                    progBar = proglist[proglist.Count -1];
                                }
                            }

                            // run anim until machine work is finished
                            else
                            {
                                if (currentFrame++ == numberOfFrames - 1)
                                {
                                    currentFrame = 0;

                                    if (action.done == true)
                                    {
                                        doing = false;
                                        action.done = false;
                                        action = null;
                                        animStart = true;

                                        if (corpseWork == true)
                                        {
                                            corpseWork = false;
                                        }
                                    }
                                }

                            }
                        }

                    }

                    // animate animation if animating....
                    else if (animating == true)
                    {
                        anim = 4;

                        if (currentFrame++ == numberOfFrames - 1)
                        {
                            doing = false;
                            animating = false;

                        }

                    }
                }

                // if not walking, stand!
                if (walking == false && doing == false)
                {
                    anim = 2;
                    currentFrame = 0;
                }

                // set anim and frame
                rect.X = currentFrame * width;
                rect.Y = height * anim;
            }
        }
Exemplo n.º 4
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...
        }
Exemplo n.º 5
0
        //===========================================================================================================================
        public void Render(GraphicsDevice graphicsDevice, SpriteBatch sbatch, SpriteFont font, Build build, Graveyard graveyard, Corpse corpse)
        {
            sbatch.Draw(cursorTex, position, rect, Microsoft.Xna.Framework.Color.White, 0, Vector2.Zero, 1.0f, SpriteEffects.None, 0.0f);

            // draw menu

            if (menu == true || graveMenu == true || corpseMenu == true)
            {
                if (click == true)
                {
                    menuPosition = position;

                }

                // find longest string in menu

                int boxWidth = 0;
                List<MenuAction> actions = new List<MenuAction> { };

                if (menu == true)
                {
                    foreach (MenuAction action in menuObject.menuActions)
                    {
                        actions.Add(action);

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

                        }
                    }
                }

                //grave menu

                if (graveMenu == true)
                {
                    foreach (MenuAction action in graveyard.menuActions)
                    {
                        actions.Add(action);

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

                        }
                    }
                }

                //corpse menu

                if (corpseMenu == true )
                {
                    if (corpse.alive == false)
                    {
                        foreach (MenuAction action in corpse.deadMenuActions)
                        {
                            actions.Add(action);

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

                            }
                        }
                    }

                    if (corpse.alive == true)
                    {
                        foreach (MenuAction action in corpse.aliveMenuActions)
                        {
                            actions.Add(action);

                            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
                Vector2 menuItemPosition = menuPosition;    // position of each text menu item

                menuMouseover = false;

                foreach (MenuAction action in actions)
                {
                    // declare colours
                    Color textColour;
                    Color boxColour;
                    Color lineColour;

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

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

                        menuHighlightAction = action;
                        menuMouseover = true;
                    }

                    // IF NOT MOUSE-OVERED
                    else
                    {
                        textColour = Color.White;
                        boxColour = Color.Gray;
                        lineColour = Color.DarkGray;

                    }

                    // text

                    sbatch.DrawString(font, action.name, menuItemPosition + new Vector2(5,0), textColour, 0, Vector2.Zero, 1.0f, SpriteEffects.None, 0.13f);

                    // text rectangle
                    sbatch.Draw(dummyTexture, menuItemPosition , menuRectangle, boxColour, 0, Vector2.Zero, 1.0f, SpriteEffects.None, 0.17f);

                    // top line
                    Tuple<Vector2, Vector2> line = new Tuple<Vector2, Vector2>(menuItemPosition, (menuItemPosition + new Vector2(menuRectangle.Width, 0)));

                    float angle = (float)Math.Atan2(line.Item2.Y - line.Item1.Y, line.Item2.X - line.Item1.X);
                    float length = Vector2.Distance(line.Item1, line.Item2);

                    sbatch.Draw(dummyTexture, line.Item1 + new Vector2(0, 0), null, lineColour, angle, Vector2.Zero, new Vector2(length, 3.0f), SpriteEffects.None, 0.15f);

                    // right line
                    Tuple<Vector2, Vector2> line2 = new Tuple<Vector2, Vector2>((menuItemPosition + new Vector2(menuRectangle.Width, menuRectangle.Height)), (menuItemPosition + new Vector2(menuRectangle.Width, 0)));

                    float angle2 = (float)Math.Atan2(line2.Item2.Y - line2.Item1.Y, line2.Item2.X - line2.Item1.X);
                    float length2 = Vector2.Distance(line2.Item1, line2.Item2);

                    sbatch.Draw(dummyTexture, line2.Item1 + new Vector2(0, 0), null, lineColour, angle2, Vector2.Zero, new Vector2(length2, 3.0f), SpriteEffects.None, 0.15f);

                    // left line
                    Tuple<Vector2, Vector2> line3 = new Tuple<Vector2, Vector2>(menuItemPosition, (menuItemPosition + new Vector2(0, menuRectangle.Height)));

                    float angle3 = (float)Math.Atan2(line3.Item2.Y - line3.Item1.Y, line3.Item2.X - line3.Item1.X);
                    float length3 = Vector2.Distance(line3.Item1, line3.Item2);

                    sbatch.Draw(dummyTexture, line3.Item1 + new Vector2(0, 0), null, lineColour, angle3, Vector2.Zero, new Vector2(length3, 3.0f), SpriteEffects.None, 0.15f);

                    // bottom line
                    Tuple<Vector2, Vector2> line4 = new Tuple<Vector2, Vector2>((menuItemPosition + new Vector2(menuRectangle.Width, menuRectangle.Height)), (menuItemPosition + new Vector2(0, menuRectangle.Height)));

                    float angle4 = (float)Math.Atan2(line4.Item2.Y - line4.Item1.Y, line4.Item2.X - line4.Item1.X);
                    float length4 = Vector2.Distance(line4.Item1, line4.Item2);

                    sbatch.Draw(dummyTexture, line4.Item1 + new Vector2(0, 0), null, lineColour, angle4, Vector2.Zero, new Vector2(length4, 3.0f), SpriteEffects.None, 0.15f);

                    // set to height of next text item
                    menuItemPosition += new Vector2(0, menuRectangle.Height);

                }

            }

            // Mouse-over text

            if (mouseOver == true && menu == false && corpseMouseover == false)
            {
                //sbatch.DrawString(font, text, position + textOffset, Microsoft.Xna.Framework.Color.White, 0, Vector2.Zero, 1.0f, SpriteEffects.None, 0.2f);
                //sbatch.DrawString(font, menu.ToString() + ' ' + click.ToString()+ ' ' + mouseOver.ToString(), position + textOffset, Microsoft.Xna.Framework.Color.White, 0, Vector2.Zero, 1.0f, SpriteEffects.None, 0.2f);
                sbatch.DrawString(font, menuObject.name, position + textOffset, Microsoft.Xna.Framework.Color.White, 0, Vector2.Zero, 1.0f, SpriteEffects.None, 0.01f);
            }

            if (barMouseover == true && mouseOver == false)
            {
                string barText = menuProgBar.value.ToString("#.#") + "/" + menuProgBar.init.ToString("#.#");
                sbatch.DrawString(font, barText, position + textOffset, Microsoft.Xna.Framework.Color.White, 0, Vector2.Zero, 1.0f, SpriteEffects.None, 0.01f);
            }

            if (graveMouseOver == true && menu == false)
            {
                sbatch.DrawString(font, "Graveyard", position + textOffset, Microsoft.Xna.Framework.Color.White, 0, Vector2.Zero, 1.0f, SpriteEffects.None, 0.01f);
            }

            if (corpseMouseover == true && menu == false)
            {
                sbatch.DrawString(font, "Corpse: rot = " + corpse.rot.ToString(), position + textOffset, Microsoft.Xna.Framework.Color.White, 0, Vector2.Zero, 1.0f, SpriteEffects.None, 0.01f);
            }

            if (buildIconMouseover == true && menu == false && build.menu == true)
            {
                // tooltip
                sbatch.DrawString(font, menuObject.name + " : " + menuObject.cost.ToString(), position + textOffset, Microsoft.Xna.Framework.Color.White, 0, Vector2.Zero, 1.0f, SpriteEffects.None, 0.01f);

                // highlight box

                // top line
                Tuple<Vector2, Vector2> line = new Tuple<Vector2, Vector2>(menuObject.iconPosition, (menuObject.iconPosition + new Vector2(60, 0)));

                float angle = (float)Math.Atan2(line.Item2.Y - line.Item1.Y, line.Item2.X - line.Item1.X);
                float length = Vector2.Distance(line.Item1, line.Item2);

                sbatch.Draw(dummyTexture, line.Item1 + new Vector2(0, 0), null, highlightColour, angle, Vector2.Zero, new Vector2(length, 3.0f), SpriteEffects.None, 0.15f);

                // right line
                Tuple<Vector2, Vector2> line2 = new Tuple<Vector2, Vector2>((menuObject.iconPosition + new Vector2(60, 60)), (menuObject.iconPosition + new Vector2(60, 0)));

                float angle2 = (float)Math.Atan2(line2.Item2.Y - line2.Item1.Y, line2.Item2.X - line2.Item1.X);
                float length2 = Vector2.Distance(line2.Item1, line2.Item2);

                sbatch.Draw(dummyTexture, line2.Item1 + new Vector2(0, 0), null, highlightColour, angle2, Vector2.Zero, new Vector2(length2, 3.0f), SpriteEffects.None, 0.15f);

                // left line
                Tuple<Vector2, Vector2> line3 = new Tuple<Vector2, Vector2>(menuObject.iconPosition, (menuObject.iconPosition + new Vector2(0, 60)));

                float angle3 = (float)Math.Atan2(line3.Item2.Y - line3.Item1.Y, line3.Item2.X - line3.Item1.X);
                float length3 = Vector2.Distance(line3.Item1, line3.Item2);

                sbatch.Draw(dummyTexture, line3.Item1 + new Vector2(0, 0), null, highlightColour, angle3, Vector2.Zero, new Vector2(length3, 3.0f), SpriteEffects.None, 0.15f);

                // bottom line
                Tuple<Vector2, Vector2> line4 = new Tuple<Vector2, Vector2>((menuObject.iconPosition + new Vector2(60, 60)), (menuObject.iconPosition + new Vector2(0, 60)));

                float angle4 = (float)Math.Atan2(line4.Item2.Y - line4.Item1.Y, line4.Item2.X - line4.Item1.X);
                float length4 = Vector2.Distance(line4.Item1, line4.Item2);

                sbatch.Draw(dummyTexture, line4.Item1 + new Vector2(0, 0), null, highlightColour, angle4, Vector2.Zero, new Vector2(length4, 3.0f), SpriteEffects.None, 0.15f);

            }
        }
Exemplo n.º 6
0
        public void Update(GameTime gameTime, MenuAction dissect, MenuAction study,NumericalCounter longevity, NumericalCounter humanity, NumericalCounter lifeforce, Scientist scientist, Assistant assistant,
                                MenuAction talk, Cursor cursor,List<MiniProgressBar> bars, MenuAction clearCorpse)
        {
            cursor.corpseMouseover = false;

            if (flyTimer >= flyTime && alive == false)
            {
                flyTimer = 0;
                flies.AddFlies(1);
            }

            flyTimer += gameTime.ElapsedGameTime.Milliseconds;

            if (flyTimer >= flyLossTime && visible == false)
            {
                if (flies.flies.Count > 0)
                {
                    flyTimer = 0;
                    flies.RemoveFlies(1);
                }
            }

            if (this.visible == true)
            {

                // update cut up-ness
                if (dead == false)
                {
                    cut = dissect.count * 3 + study.count;
                }

                if (cut > 3)
                {
                    cut = 3;
                }

                // check for mouseover & click

                if (cursor.position.X >= position.X && cursor.position.X <= position.X + fwidth*scale
                           && cursor.position.Y >= position.Y  && cursor.position.Y <= position.Y + height  && visible == true && corpseMenu == false)
                {

                    cursor.corpseMouseover = true; // add object mouseover text

                    // turn on menu when object is clicked

                    if (cursor.mouseState.LeftButton == ButtonState.Pressed | cursor.mouseState.RightButton == ButtonState.Pressed)
                    {
                        if (cursor.click == false)
                        {
                            corpseMenu = true;
                            menuOpen = true;
                            cursor.corpseMouseover = false;
                        }

                        cursor.click = true;
                    }
                }

                // rotting timer and count and flies

                timer += gameTime.ElapsedGameTime.Milliseconds;
                rotTimer += gameTime.ElapsedGameTime.Milliseconds;
                colorTimer += gameTime.ElapsedGameTime.Milliseconds;

                if (rotTimer >= rotTime * 1000.0 && alive == false && dead == false)
                {
                    rotTimer = 0;

                    if (rot.value > 1)
                    {
                        rot.value -= 1;
                        flyTime -= 1500;
                    }

                    else
                    {
                        Die();
                        corpseColor = Microsoft.Xna.Framework.Color.Brown;
                        rot.value = 3;
                    }
                }

                if (colorTimer >= colorTime)
                {
                    colorTimer = 0;
                    if (corpseColor.R > 90)
                    {
                        this.corpseColor.R -= 1;
                    }
                    if (corpseColor.B > 0)
                    {
                        this.corpseColor.B -= 1;
                    }
                    if (corpseColor.G > 60)
                    {
                        this.corpseColor.G -= 1;
                    }
                }

                // live corpse dead count && anim change

                if (alive == true)
                {
                    longevity.valueChange = -0.01f;

                    if (longevity.value == 0)
                    {
                        Die();
                    }

                    if (scientist.action == talk && scientist.doing == true)
                    {

                        talking = true;
                        anim = 2;
                        frames = nframes[2];
                    }
                    else
                    {
                        talking = false;
                        anim = 1;
                        frames = nframes[1];
                    }

                }

                else if (dead == false)
                {
                    longevity.valueChange = 0;

                    anim = 0;
                    frames = nframes[0];
                }

                // kill if dissected

                if (dissect.done == true)
                {
                    Die();
                }

                // kill if studies 3 times

                if (study.count >= 3)
                {
                    Die();
                }

                // update anim

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

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

                    rect.Y = cut * height + currentFrame; // * fwidth
                }

                // menu setup

                if (corpseMenu == true && menuOpen == true)
                {
                    menuPosition = cursor.position;
                    menuOpen = false;

                    // find longest string in menu

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

                    if (alive == false && dead == false)
                    {
                        menuActions = workMenuActions;

                        foreach (MenuAction action in workMenuActions)
                        {
                            // 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

                            }
                        }
                    }

                    if (alive == true)
                    {
                        menuActions = aliveMenuActions;

                        foreach (MenuAction action in aliveMenuActions)
                        {
                            // 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

                            }
                        }
                    }

                    if (dead == true)
                    {
                        menuActions = deadMenuActions;

                        foreach (MenuAction action in deadMenuActions)
                        {
                            // 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 (corpseMenu == 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)
                                {
                                    corpseMenu = 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.corpseWork = true;
                                        }

                                        if (action.assistant == true)
                                        {
                                            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.corpseWork = true;

                                        }

                                    }

                                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)
                                {
                                    corpseMenu = 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);

                    }
                }
            }

            // check for cleared up dead corpse, reset corpse if so.

            if (clearCorpse.count > 0)
            {
                clearCorpse.count = 0;
                visible = false;
                dead = false;
                corpseColor = Color.White;
                rot.value = 3;
            }

            // update the rot counter
            rot.Update(gameTime);

            // update fly swarm

            flies.Update();
        }
Exemplo n.º 7
0
        public void Update(GameTime gameTime, Cursor cursor, List<FloorObject> floorObjectList, FloorObject table, Assistant assistant, Corpse corpse, List<MiniProgressBar> bars,MenuAction dissect,MenuAction study)
        {
            if (floorObjectList.Contains(table) && assistant.digging == false && corpse.visible == false && assistant.outside == false && assistant.corpseCarrying == false)
            {
                doable = true;
            }

            else
            {
                doable = false;
            }

            // clicking on build icon

            if (cursor.position.X >= iposition.X && cursor.position.X < (iposition.X + iwidth) && cursor.position.Y >= iposition.Y && cursor.position.Y < (iposition.Y + iheight))
            {
                high = true;

                if (cursor.mouseState.LeftButton == ButtonState.Pressed | cursor.mouseState.RightButton == ButtonState.Pressed)
                {
                    if (cursor.click == false)
                    {
                        if (doable == true)
                        {
                            assistant.DigUpCorpse(corpse,dissect,study);
                            clickOn = true;
                        }

                    }

                    cursor.click = true;
                }
            }

            else
            {
                high = false;
            }

            if (clickOn == true)
            {
                clickCount += gameTime.ElapsedGameTime.Milliseconds;

                if (clickCount > 100)
                {
                    clickCount = 0;
                    clickOn = false;
                }
            }
        }
Exemplo n.º 8
0
        public void Update(GameTime gameTime, Cursor cursor, List<FloorObject> floorObjectList, FloorObject table, Assistant assistant, Corpse corpse, List<MiniProgressBar> bars)
        {
            // check for mouseover and click

            if (menu == false)
            {

                cursor.graveMouseOver = false;

                // graveyard
                if (cursor.position.X >= tlcorner.X && cursor.position.X <= brcorner.X
                        && cursor.position.Y >= tlcorner.Y && cursor.position.Y <= brcorner.Y)
                {

                    cursor.graveMouseOver = true; // add object mouseover text

                    // 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.graveMouseOver = false;
                        }

                        cursor.click = true;

                    }
                }
            }

            if (menu == true)
            {

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

                        menu = false;

                        if (menuMouseover == true)
                        {
                            if (floorObjectList.Contains(table))
                            {
                                assistant.DigUpCorpse(corpse);
                            }
                        }

                    }

                    cursor.click = true;
                }

            }

            // 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
            }

            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;
                    }

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

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

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

                            if (menuMouseover == true)
                            {

                                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;
                                    }

                                }

                            }

                        }

                        cursor.click = true;
                    }

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

                }
            }
        }
Exemplo n.º 9
0
        public void Update(GameTime gametime, GraphicsDevice graphicsDevice, Grid grid, Cursor cursor, NumericalCounter research, NumericalCounter money, 
                                        NumericalCounter madness, List<MiniProgressBar> proglist, Corpse corpse,NonInteractive door,NonInteractive digger, Resurrect resurrect, NonInteractive Switch,
                                        NumericalCounter humanity, NumericalCounter longevity,NumericalCounter lifeForce, Random random, ReachableArea reachable)
        {
            path.Update(reachable);

            if (outside == false)
            {
                position = grid.CartesianCoords(gridPosition);

                if (walking == true)
                {
                    layer = 0.21f + (0.2f / (float)grid.rows) * walkingTarget.Y + (0.2f / ((float)grid.columns * (float)grid.rows + 1)) * Math.Abs(walkingTarget.X - (float)grid.columns / 2.0f);
                }

                else
                {
                    layer = 0.21f + (0.2f / (float)grid.rows) * gridPosition.Y + (0.2f / ((float)grid.columns * (float)grid.rows + 1)) * Math.Abs(gridPosition.X - (float)grid.columns / 2.0f);
                }
            }

            offset = new Vector2((width * scale) / 2.0f, height * scale); // factor of 2 here and in the draw command are just for this test anim, so it's a decent size...

            // walking....

            // to use a machine
            if (action != null && walking == false && doing == false)
            {

                // to corpse
                if (corpseWork == true)
                {
                    if (gridPosition != tableLocation)
                    {
                        walking = true;
                        drawPath = path.PathList(gridPosition, tableLocation, grid);
                        pathStep = 1;
                        walkingTarget = drawPath[pathStep];
                    }

                    else
                    {
                        doing = true;
                        currentFrame = 0;
                        gridPosition = drawPath[pathStep - 1];
                        position = grid.CartesianCoords(gridPosition);
                    }
                }

                else if (gridPosition != floorObject.opPos)
                {
                    walking = true;

                    drawPath = path.PathList(gridPosition, floorObject.opPos, grid);

                    pathStep = 1;

                    walkingTarget = drawPath[pathStep];
                }

                else
                {
                    doing = true;
                    currentFrame = 0;
                    gridPosition = drawPath[pathStep - 1];
                    position = grid.CartesianCoords(gridPosition);
                }

            }

            else if (gridPosition != defaultGridPosition && walking == false && doing == false)
            {
                walking = true;
                drawPath = path.PathList(gridPosition, defaultGridPosition, grid);
                pathStep = 1;
                walkingTarget = drawPath[pathStep];
            }

            // if he's walking, make him walk!

            if (walking == true)
            {

                direction = (grid.CartesianCoords(walkingTarget) - grid.CartesianCoords(gridPosition));

                targetDistance = direction.Length();
                direction.Normalize();

                walkingOffset += direction * gametime.ElapsedGameTime.Milliseconds * 0.2f;
                distanceGone = walkingOffset.Length();

                if (distanceGone < targetDistance)
                {
                    Vector2 move = walkingOffset;
                    position += move;
                }

                else
                {
                    pathStep += 1;

                    if (pathStep < drawPath.Count)
                    {
                        gridPosition = drawPath[pathStep - 1];
                        walkingTarget = drawPath[pathStep];
                        position = grid.CartesianCoords(gridPosition);
                    }

                    else
                    {
                        walking = false;
                        doing = true;
                        currentFrame = 0;
                        gridPosition = drawPath[pathStep - 1];
                        position = grid.CartesianCoords(gridPosition);
                    }

                    walkingOffset = Vector2.Zero;
                    targetDistance = 0;
                    distanceGone = 0;

                }
            }

            // update animation frame

            timer += gametime.ElapsedGameTime.Milliseconds;

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

                if (walking == true)
                {
                    if (Math.Abs(direction.X) >= Math.Abs(direction.Y))
                    {
                        if (direction.X >= 0)
                        {
                            anim = 1;
                        }

                        else
                        {
                            anim = 0;
                        }
                    }

                    if (Math.Abs(direction.Y) >= Math.Abs(direction.X))
                    {
                        if (direction.Y >= 0)
                        {
                            anim = 2;
                        }

                        else
                        {
                            anim = 3;
                        }
                    }

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

                // start up menu action if doing is done, animate doing
                if (doing == true)
                {
                    // coming through door (either way)
                    if (digging == true)
                    {
                        anim = 4;

                        if (door.animNum == 0)
                        {
                            door.SetAnim(1);
                            door.layer -= 0.3f;
                        }

                        if (currentFrame++ == 2)
                        {

                            digging = false;

                            if (dug == true)
                            {
                                CarryCorpse();
                                doing = false;
                                dug = false;
                                outside = false;
                            }

                            else
                            {
                                outside = true;
                                layer = 0.61f;
                                position += new Vector2(0, -20);
                            }

                            currentFrame = 0;
                            door.SetAnim(0);
                            door.layer += 0.3f;
                        }

                        else if (dug == true)
                        {
                            layer = 0.595f;
                            anim = 5;
                        }
                    }

                    // animate digging outside
                    else if (outside == true)
                    {
                        outTimer += gametime.ElapsedGameTime.Milliseconds;

                        if (outTimer >= 150 && dug == false)
                        {
                            digger.anim = true;
                            dug = true;
                            outTimer = 0;
                        }

                        if (dug == true && digger.anim == false && outTimer >= 350)
                        {
                            digging = true;
                            outTimer = 0;

                        }
                    }

                    // animate putting corpse on table
                    else if (corpseCarrying == true)
                    {

                        doing = false;
                        corpseCarrying = false;
                        corpse.flies.Restart(0);
                        corpse.visible = true;
                    }

                    // animate animation!
                    else if (animating == true)
                    {
                        anim = 4;

                        if (currentFrame++ == numberOfFrames - 1)
                        {
                            doing = false;
                            animating = false;
                            Switch.SetAnim(1);
                            resurrect.Alive(corpse, humanity, longevity,lifeForce, research,madness, random, this);
                        }
                    }

                    // if not in the usual spot...
                    else if (gridPosition != defaultGridPosition)
                    {
                        anim = 4;

                        if (action != null)
                        {
                            // if not staying to run machine, run doing anim once, create mini progress bar
                            if (action.remain == false)
                            {
                                if (currentFrame++ == numberOfFrames - 1)
                                {
                                    doing = false;
                                    proglist.Add(new MiniProgressBar(graphicsDevice, floorObject.position + new Vector2(-5, -105), action, floorObject));
                                    progBar = proglist[proglist.Count - 1];
                                    action = null;

                                }
                            }

                            // if staying to run machine...
                            else
                            {
                                // create a progess bar if starting
                                if (animStart == true)
                                {
                                    animStart = false;

                                    if (corpseWork == true)
                                    {
                                        proglist.Add(new MiniProgressBar(graphicsDevice, corpse.position + new Vector2(-5, -105), action, floorObject));
                                        progBar = proglist[proglist.Count - 1];
                                        corpseWork = false;
                                    }

                                    else
                                    {
                                        proglist.Add(new MiniProgressBar(graphicsDevice, floorObject.position + new Vector2(-5, -105), action, floorObject));
                                        progBar = proglist[proglist.Count - 1];
                                    }
                                }

                                // run animation until finished
                                else
                                {
                                    if (currentFrame++ == numberOfFrames - 1)
                                    {
                                        currentFrame = 0;

                                        if (action.done == true)
                                        {
                                            doing = false;
                                            action.done = false;
                                            action = null;
                                            animStart = true;

                                        }
                                    }

                                }
                            }
                        }
                    }

                    // if not doing anything, stop...
                    else
                    {
                        walking = false;
                        doing = false;
                        currentFrame = 0;
                    }

                }

                // if not walking, do standing anim
                if (walking == false && doing == false)
                {
                    anim = 2;
                    currentFrame = 0;
                }

                // set frame and anim
                rect.X = currentFrame * width;
                rect.Y = height * anim;
            }
        }
Exemplo n.º 10
0
        // dig up corpse!
        public void DigUpCorpse(Corpse corpse, MenuAction dissect, MenuAction study)
        {
            if (corpse.visible == false)
            {
                digging = true;
                walking = true;
                drawPath = path.PathList(gridPosition, doorLocation, grid);
                pathStep = 1;
                walkingTarget = drawPath[pathStep];
                corpse.rot.value = 3;
                corpse.cut = 0;

                dissect.count = 0;
                study.count = 0;
            }
        }