Uploaded source code for ShiftOS 0.1.1 Beta 2.3

Initial commit of repository.

1 files changed, 322 insertions, 0 deletions

diff --git a/source/WindowsFormsApplication1/Hacking_Enemy.cs b/source/WindowsFormsApplication1/Hacking_Enemy.cs
new file mode 100644
index 0000000..8cec39f
--- /dev/null
+++ b/source/WindowsFormsApplication1/Hacking_Enemy.cs
@@ -0,0 +1,322 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Data;
+using System.Drawing;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows.Forms;
+
+namespace ShiftOS
+{
+    public partial class Hacking_Enemy : Form
+    {
+        public Hacking_Enemy(Hacking_YourHealth enemy, EnemyHacker thisHacker)
+        {
+            ThisHacker = thisHacker;
+            Enemy = enemy;
+            InitializeComponent();
+        }
+
+        private EnemyHacker ThisHacker { get; set; }
+        public Hacking_YourHealth Enemy { get; set; }
+        public List<Computer> AllComputers = null;
+        public Computer ThisPC { get; set; }
+        private void Hacking_Enemy_Load(object sender, EventArgs e)
+        {
+            AllComputers = new List<Computer>();
+            VisualizeNetwork();
+            tmrhealthdetect.Start();
+            ThisPC.Enemy = true;
+        }
+
+        private void VisualizeNetwork()
+        {
+            var rnd = new Random();
+            foreach (Module m in ThisHacker.Network)
+            {
+                var c = m.Deploy();
+                if (c.Type == SystemType.Core)
+                {
+                    ThisPC = c;
+                    ThisPC.EnemyComputer = Enemy.ThisPC;
+                    Enemy.ThisPC.EnemyComputer = ThisPC;
+                }
+                c.Location = new Point(rnd.Next(100, 350), rnd.Next(100, 350));
+                AddModule(c);
+            }
+        }
+
+        public void System_Attacking(object s, EventArgs a)
+        {
+            int i = new Random().Next(Enemy.AllComputers.Count);
+            var pc = Enemy.AllComputers[i];
+            var se = (Computer)s;
+            pc.LaunchAttack(se.GetProperType());
+        }
+
+        public Computer SelectedComputer = null;
+
+        public void AddModule(Computer newModule)
+        {
+            var rnd = new Random();
+            panel1.Controls.Add(newModule);
+            foreach(var pc in AllComputers)
+            {
+                while (newModule.Bounds.IntersectsWith(pc.Bounds))
+                {
+                    newModule.Location = new Point(rnd.Next(100, 350), rnd.Next(100, 350));
+                }
+            }
+            AllComputers.Add(newModule);
+            int hp = newModule.HP;
+            TotalHP += (decimal)newModule.HP;
+            newModule.Show();
+            newModule.OnDestruction += (object s, EventArgs a) =>
+            {
+                if(this.SelectedComputer == newModule)
+                {
+                    SelectedComputer = null;
+                }
+                AllComputers.Remove(newModule);
+                newModule.Dispose();
+            };
+            newModule.Select += (object s, EventArgs a) =>
+            {
+                bool c = true;
+                foreach(var pc in Enemy.SelectedComputer.Enemies)
+                {
+                    if(pc.Hostname == newModule.Hostname)
+                    {
+                        c = false;
+                    }
+                }
+                if (c == true)
+                {
+                    Enemy.SelectedComputer.Enemies.Add(newModule);
+                    Enemy.ShowPCInfo(Enemy.SelectedComputer.Hostname);
+                    if(Enemy.IsTutorial)
+                    {
+                        if(Enemy.TutorialProgress == 9)
+                        {
+                            Enemy.SetupTutorialUI(10);
+                        }
+                    }
+                }
+            };
+            newModule.HP_Decreased += new EventHandler(System_Damaged);
+            newModule.OnRepair += new EventHandler(System_Repaired);
+            if (newModule.Type == SystemType.Antivirus)
+            {
+                var b = newModule.GetAreaOfEffect();
+                newModule.AntivirusRepair += (object s, EventArgs a) =>
+                {
+                    foreach (Computer pc in AllComputers)
+                    {
+                        if (pc != newModule && pc.Bounds.IntersectsWith(b))
+                        {
+                            if (newModule.Type == SystemType.RepairModule)
+                            {
+                                if (pc.HP < newModule.HP)
+                                {
+                                    if (pc.HP < pc.GetTotal())
+                                    {
+                                        pc.Repair(1);
+                                    }
+                                }
+
+                            }
+                            else {
+                                if (pc.HP < 10)
+                                {
+                                    pc.Repair(1);
+                                }
+                            }
+                        }
+                    }
+                };
+            }
+            if (newModule.Type == SystemType.Firewall)
+            {
+                panel1.Refresh();
+                Firewall_Deflect(newModule);
+            }
+            if (newModule.Type == SystemType.ServerStack)
+            {
+                newModule.MassDDoS += (object s, EventArgs a) =>
+                {
+                    Enemy.Worm();
+                };
+            }
+        }
+
+        public void Firewall_Deflect(Computer fwall)
+        {
+            //Safegaurd...
+            if (fwall.Type == SystemType.Firewall)
+            {
+                var r = fwall.GetAreaOfEffect();
+                foreach (var pc in AllComputers)
+                {
+                    if (pc != fwall)
+                    {
+                        if (pc.Bounds.IntersectsWith(r))
+                        {
+                            pc.DamageDefector = fwall.Grade;
+                        }
+                    }
+                }
+            }
+        }
+
+        public void Firewall_Destroy(Computer fwall)
+        {
+            //Safegaurd...
+            if (fwall.Type == SystemType.Firewall)
+            {
+                var r = fwall.GetAreaOfEffect();
+                foreach (var pc in AllComputers)
+                {
+                    if (pc.Bounds.IntersectsWith(r))
+                    {
+                        pc.DamageDefector = 1;
+                        UpdateFirewalls();
+                    }
+                }
+            }
+        }
+
+        public void UpdateFirewalls()
+        {
+            foreach (var pc in AllComputers)
+            {
+                if (pc.Type == SystemType.Firewall)
+                {
+                    Firewall_Deflect(pc);
+                }
+            }
+        }
+
+
+        private void System_Repaired(object s, EventArgs e)
+        {
+            var c = (Computer)s;
+            lbcompromised.Text = "System regenerating...";
+            int location = c.Left - (lbcompromised.Width / 4);
+            int y = c.Top - 25;
+            lbcompromised.Location = new Point(location, y);
+            lbcompromised.Show();
+            c.Flash(lbcompromised);
+
+        }
+
+
+        private void System_Damaged(object s, EventArgs e)
+        {
+            var c = (Computer)s;
+            lbcompromised.Text = "System damaged!";
+            int location = c.Left - (lbcompromised.Width / 4);
+            int y = c.Top - 25;
+            lbcompromised.Location = new Point(location, y);
+            lbcompromised.Show();
+            c.Flash(lbcompromised);
+        }
+
+        private decimal TotalHP = 0;
+
+        private void tmrhealthdetect_Tick(object sender, EventArgs e)
+        {
+            decimal health = 0;
+
+            var rnd = new Random();
+            int chance = 0;
+            foreach (var pc in AllComputers)
+            {
+                if (pc.Disabled == false)
+                {
+                    foreach (var enemy in Enemy.AllComputers)
+                    {
+                        chance = rnd.Next(1, 20);
+                        if (chance == 10)
+                        {
+                            if (Enemy.IsTutorial)
+                            {
+                                if (Enemy.TutorialProgress == 9)
+                                {
+                                    Enemy.ThisPC.LaunchAttack(pc.GetProperType(), pc.GetDamageRate());
+                                }
+                                else if (Enemy.TutorialProgress == 32)
+                                {
+                                    enemy.LaunchAttack(pc.GetProperType(), pc.GetDamageRate());
+                                }
+                                else
+                                {
+                                    enemy.Enemies.Clear();
+                                }
+                            }
+                            else {
+                                enemy.LaunchAttack(pc.GetProperType(), pc.GetDamageRate());
+                            }
+                        }
+                    }
+                }
+            }
+
+            foreach (var pc in AllComputers)
+            {
+                health += (decimal)pc.HP;
+            }
+            try {
+                decimal percent = (health / TotalHP) * 100;
+                lbstats.Text = $"Enemy Health: {percent}%";
+                if (ThisPC.HP <= 0)
+                {
+                    if (Enemy.IsTutorial)
+                    {
+                        Enemy.SetupTutorialUI(33);
+                    }
+                    else {
+                        API.CreateInfoboxSession("You won.", "You have successfully overthrown the enemy network.", infobox.InfoboxMode.Info);
+                        UserRequestedClose = false;
+                        Enemy.UserRequestedClose = false;
+                        Enemy.Close();
+                        this.Close();
+                    }
+                }
+            }
+            catch(Exception ex)
+            {
+
+            }
+        }
+
+        public void Worm()
+        {
+            var rnd = new Random();
+            int r = rnd.Next(0, 10);
+
+            foreach (Computer c in AllComputers)
+            {
+                if(r == 5)
+                {
+                    c.Disable();
+                }
+            }
+        }
+
+        public bool UserRequestedClose = true;
+
+        private void this_Closing(object sender, FormClosingEventArgs e)
+        {
+            if(UserRequestedClose == false)
+            {
+                tmrhealthdetect.Stop();
+                foreach(var pc in AllComputers)
+                {
+                    pc.HP = 0;
+                }
+            }
+        }
+    }
+}