//===========================================================================================================================
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);
// Mouse-over text
if (mouseOver == true && menu == false && corpseMouseover == false)
{
sbatch.DrawString(font, menuObject.name, 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.value.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);
}
}
public void Alive(Corpse corpse, NumericalCounter humanity, NumericalCounter longevity, NumericalCounter lifeForce, NumericalCounter research, NumericalCounter madness, Random random, Assistant assistant)
{
fail = false;
double rnd = random.NextDouble(); // produce a random number
float chance = 1.0f * (research.value/raiseResearch)* (corpse.rot.value/3.0f) * (float) rnd; // calculate a resurrection chance based on amount of research done and corpse freshness
// resurrect if successful
if (chance > 0.9f && longevity.value > 0 && lifeForce.value == 100)
{
double rnd1 = random.NextDouble(); // create a set of random numbers
double rnd2 = random.NextDouble();
double rnd3 = random.NextDouble();
longevity.value = (float)((rnd1 + rnd2 + rnd3) / 3.0 + 0.5) * longevity.value; // create a pseudo-normal random value between 0.5 and 1.5 and multiply by the longevity
double rnd4 = random.NextDouble(); // create a set of random numbers
double rnd5 = random.NextDouble();
double rnd6 = random.NextDouble();
humanity.value = (float)((rnd4 + rnd5 + rnd6) / 3.0 + 0.5) * humanity.value; // create a pseudo-normal random value between 0.5 and 1.5 and multiply by the humanity
corpse.alive = true;
research.value += 150;
madness.value += 20;
}
// else it fails...
else
{
corpse.Die();
fail = true;
research.value += 50;
madness.value += 5;
}
}
public void Update(Corpse corpse,NumericalCounter lifeForce, NumericalCounter humanity, NumericalCounter longevity, FloorObject conductor,
GameTime gameTime, Cursor cursor,Scientist scientist, Assistant assistant)
{
// check if resurrection is possible
if (conductor.on == true && corpse.visible == true && corpse.alive == false)
{
doable = true;
}
else
{
doable = false;
}
MouseState mouseState = Mouse.GetState();
// clicking on animate icon
if (cursor.position.X >= position.X && cursor.position.X < (position.X + tex.Width) && cursor.position.Y >= position.Y && cursor.position.Y < (position.Y + tex.Height))
{
if (mouseState.LeftButton == ButtonState.Pressed | mouseState.RightButton == ButtonState.Pressed)
{
if (cursor.click == false && doable == true)
{
Animate(scientist, assistant);
clickOn = true;
}
cursor.click = true;
}
}
if (clickOn == true)
{
clickCount += gameTime.ElapsedGameTime.Milliseconds;
if (clickCount > 100)
{
clickCount = 0;
clickOn = false;
}
}
}
// === 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...
}
//===========================================================================================================================
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);
}
}
public void Update(List<FloorObject> floorObjectList, List<MiniProgressBar> progBars,Scientist scientist, Assistant assistant, Build build, Graveyard graveyard,FloorObject table, Corpse corpse, NumericalCounter money,
Path path, List<Vector2> drawPath,Grid grid, Resurrect resurrect, NumericalCounter humanity, NumericalCounter longevity, NumericalCounter research, Random random)
{
MouseState mouseState = Mouse.GetState();
// Put the cursor where the mouse is constantly
position.X = mouseState.X;
position.Y = mouseState.Y;
mouseOver = false;
// check if over a progress bar, show values if so
barMouseover = false;
foreach (MiniProgressBar bar in progBars)
{
// if menu is off, check if over an object, open menu if clicked
if (menu == false)
{
// objects
if (position.X >= bar.position.X && position.X <= (bar.position.X + bar.width)
&& position.Y >= bar.position.Y && position.Y <= (bar.position.Y + bar.height))
{
barMouseover = true; // add object mouseover text
menuProgBar = bar;
}
}
}
// check for clicking on/mouseover build icons
buildIconMouseover = false;
foreach (FloorObject curitem in build.buildList)
{
if (position.X >= curitem.iconPosition.X && position.X <= curitem.iconPosition.X + 60
&& position.Y >= curitem.iconPosition.Y && position.Y <= curitem.iconPosition.Y + 60)
{
if (curitem.onBuildList == true && build.buildList.IndexOf(curitem) < (build.scrollPos + build.buildScreenLength) && build.buildList.IndexOf(curitem) >= build.scrollPos)
{
// tooltip + highlighting on
buildIconMouseover = true;
menuObject = curitem;
// build!
if (mouseState.LeftButton == ButtonState.Pressed | mouseState.RightButton == ButtonState.Pressed)
{
if (click == false)
{
if (money.value >= curitem.cost)
{
remove = curitem;
floorObjectList.Add(curitem);
build.menu = false;
}
}
}
click = true;
}
}
}
// remove anything that has been built from build list
if (remove != null)
{
build.Remove(remove,money);
remove = null;
}
// check for clicking on objects
// if menu is off, check if over an object, open menu if clicked & check for clicking on graveyard + tooltip
if (menu == false && graveMenu == false && corpseMenu == false)
{
foreach (FloorObject floorObject in floorObjectList)
{
// objects
if (position.X >= (floorObject.position.X - floorObject.offset.X) && position.X <= (floorObject.position.X - floorObject.offset.X + ((floorObject.objectTex.Width*floorObject.scale) / floorObject.frames))
&& position.Y >= floorObject.position.Y - floorObject.offset.Y && position.Y <= (floorObject.position.Y - floorObject.offset.Y + (floorObject.objectTex.Height*floorObject.scale)))
{
if (floorObject.menuActions.Count > 0)
{
mouseOver = true; // add object mouseover text
menuObject = floorObject;
// turn on menu when object is clicked
if (mouseState.LeftButton == ButtonState.Pressed | mouseState.RightButton == ButtonState.Pressed)
{
if (click == false)
{
menu = true;
}
}
click = true;
}
}
}
graveMouseOver = false;
// graveyard
if (position.X >= graveyard.tlcorner.X && position.X <= graveyard.brcorner.X
&& position.Y >= graveyard.tlcorner.Y && position.Y <= graveyard.brcorner.Y)
{
graveMouseOver = true; // add object mouseover text
// turn on menu when object is clicked
if (mouseState.LeftButton == ButtonState.Pressed | mouseState.RightButton == ButtonState.Pressed)
{
if (click == false)
{
graveMenu = true;
graveMouseOver = false;
}
}
click = true;
}
corpseMouseover = false;
// corpse
if (position.X >= corpse.position.X && position.X <= corpse.position.X + corpse.width
&& position.Y >= corpse.position.Y && position.Y <= corpse.position.Y + corpse.height && corpse.visible == true)
{
corpseMouseover = true; // add object mouseover text
// turn on menu when object is clicked
if (mouseState.LeftButton == ButtonState.Pressed | mouseState.RightButton == ButtonState.Pressed)
{
if (click == false)
{
corpseMenu = true;
corpseMouseover = false;
}
}
click = true;
}
}
// allow clicking on actions, turn off menu when anything else is clicked (if on)
if (menu == true)
{
if (mouseState.LeftButton == ButtonState.Pressed | mouseState.RightButton == ButtonState.Pressed)
{
if (click == false)
{
if (menu == true)
{
menu = false;
if (menuMouseover == true)
{
if (menuHighlightAction.scientist == true)
{
scientist.action = menuHighlightAction;
scientist.floorObject = menuObject;
}
else
{
assistant.action = menuHighlightAction;
assistant.floorObject = menuObject;
}
}
}
}
click = true;
}
}
if (graveMenu == true)
{
if (mouseState.LeftButton == ButtonState.Pressed | mouseState.RightButton == ButtonState.Pressed)
{
if (click == false)
{
graveMenu = false;
if (menuMouseover == true)
{
if (floorObjectList.Contains(table))
{
assistant.DigUpCorpse(corpse);
}
}
}
click = true;
}
}
if (corpseMenu == true)
{
if (mouseState.LeftButton == ButtonState.Pressed | mouseState.RightButton == ButtonState.Pressed)
{
if (click == false)
{
corpseMenu = false;
if (menuMouseover == true)
{
scientist.action = menuHighlightAction;
scientist.corpseWork = true;
//scientist.floorObject = menuObject;
}
}
click = true;
}
}
// clicking on animate icon
if (position.X >= resurrect.position.X && position.X < (resurrect.position.X + resurrect.tex.Width) && position.Y >= resurrect.position.Y && position.Y < (resurrect.position.Y + resurrect.tex.Height))
{
if (mouseState.LeftButton == ButtonState.Pressed | mouseState.RightButton == ButtonState.Pressed)
{
if (click == false && resurrect.doable == true)
{
resurrect.Animate(corpse, humanity, longevity, research, random);
}
click = true;
}
}
// clicking on build icon
if (position.X >= build.position.X && position.X < (build.position.X + build.tex.Width) && position.Y >= build.position.Y && position.Y < (build.position.Y + build.tex.Height))
{
if (mouseState.LeftButton == ButtonState.Pressed | mouseState.RightButton == ButtonState.Pressed)
{
if (click == false)
{
build.menu = true;
build.scrollPos = 0;
}
click = true;
}
}
else
{
if ((mouseState.LeftButton == ButtonState.Pressed | mouseState.RightButton == ButtonState.Pressed) && position.Y < build.buildPos.Y)
{
if (click == false)
{
build.menu = false;
}
click = true;
}
}
// Scrolling build menu....
// Right
if (position.X >= build.rightArrowPos.X - build.arrow.Width && position.X <= build.rightArrowPos.X
&& position.Y >= build.rightArrowPos.Y && position.Y <= build.rightArrowPos.Y + build.arrow.Height)
{
if (mouseState.LeftButton == ButtonState.Pressed | mouseState.RightButton == ButtonState.Pressed)
{
if (click == false)
{
build.ScrollRight();
}
click = true;
}
}
// Left
if (position.X >= build.leftArrowPos.X && position.X <= build.leftArrowPos.X + build.arrow.Width
&& position.Y >= build.leftArrowPos.Y - build.arrow.Height && position.Y <= build.leftArrowPos.Y)
{
if (mouseState.LeftButton == ButtonState.Pressed | mouseState.RightButton == ButtonState.Pressed)
{
if (click == false)
{
build.ScrollLeft();
}
click = true;
}
}
// turn off click flag when no longer clicking
if (mouseState.LeftButton == ButtonState.Released && mouseState.RightButton == ButtonState.Released)
{
click = false;
}
text = position.ToString();
}
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;
}
}
}
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);
}
}
}
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;
}
}
// 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;
}
}
