Changeset 139


Ignore:
Timestamp:
04/24/12 12:24:20 (3 years ago)
Author:
zpurdy
Message:

Added a whole bunch of objects to the EnergyTransfer? MiniGame?

Location:
Code/oMaE/oMaE/Widgets/EnergyTransferWidgets
Files:
6 edited
7 copied

Legend:

Unmodified
Added
Removed
  • Code/oMaE/oMaE/Widgets/EnergyTransferWidgets/ConnectableSlot.cs

    r126 r139  
    2222        public static int ConnectableHeight = 10;
    2323
     24        public int startX;
     25        public int endX;
     26
    2427
    2528        public ConnectableSlot(EnergyTransfer parent, int x, int y, Slot In, Slot Out)
     
    2831            this.In = In;
    2932            this.Out = Out;
    30             Location = new Rectangle(x, y, ConnectableWidth, ConnectableHeight);
     33            location = new Rectangle(x, y, ConnectableWidth, ConnectableHeight);
    3134            connectedPiece = null;
    3235        }
     
    3538        {
    3639            return 2*parent.SlotDistance;
     40        }
     41
     42        public override void Update()
     43        {
     44            if (In is ConnectableSlot)
     45            {
     46                startX = location.X + ConnectableWidth / 2 - getSlotLength() / 4;
     47            }
     48            else if (In is ImageSlot)
     49            {
     50                startX = ((ImageSlot)In).EndX;
     51            }
     52
     53            if (Out is ConnectableSlot)
     54            {
     55                endX = location.X + ConnectableWidth / 2 + getSlotLength() / 4;
     56            }
     57            else
     58            {
     59                endX = Out.location.X;
     60            }
     61
     62            base.Update();
    3763        }
    3864
     
    4975        public override void Draw(Screen2D screen)
    5076        {
    51             screen.FillRectangle(Location, Color.Black);
     77            screen.FillRectangle(location, Color.Black);
    5278            base.Draw(screen);
    5379        }
  • Code/oMaE/oMaE/Widgets/EnergyTransferWidgets/Cord.cs

    r135 r139  
    1616
    1717   
    18     public class Pipe : Piece
     18    public class Cord : Piece
    1919    {
    20         static Texture2D PipeSprite;
    21         static Texture2D HeatedPipeSprite;
     20        static Texture2D CordSprite;
     21        static Texture2D ElectricCordSprite;
    2222
    23         public Pipe(EnergyTransfer parent, bool draggable, int x, int y)
     23        public Cord(EnergyTransfer parent, bool draggable, int x, int y)
    2424        {
    25             Width = 150;
    26             Height = 40;
     25            Width = 120;
     26            Height = 20;
     27            toolTipText = "In: Electric     Out: Electric";
     28            name = "Power Cord";
    2729            this.parent = parent;
    2830            this.draggable = draggable;
    2931            location = new Rectangle(x, y, Width, Height);
    3032            origLocation = new Rectangle(x, y, Width, Height);
    31             energyIn.Add(EnergyTypes.Heat);
    32             energyOut = EnergyTypes.Heat;
     33            energyIn.Add(EnergyTypes.Electric);
     34            energyOut = EnergyTypes.Electric;
    3335            animateCounter = -1;
    3436            AnimateTime = 200;
     
    3739        public override void LoadContent(ContentManager Content)
    3840        {
    39             PipeSprite = Content.Load<Texture2D>("Sprites/rodseg");
    40             HeatedPipeSprite = Content.Load<Texture2D>("Sprites/heatedrodseg");
     41            CordSprite = Content.Load<Texture2D>("Sprites/powercable");
     42            ElectricCordSprite = Content.Load<Texture2D>("Sprites/powercable"); //Until we get new art
    4143            base.LoadContent(Content);
    4244        }
     
    4446        public override void Draw(Screen2D screen)
    4547        {
     48            if (displayToolTip)
     49            {
     50                DrawToolTip(screen);
     51            }
     52
    4653            if (animateCounter < 0)
    4754            {
    4855                if (connectedSlot != null)
    4956                {
    50                     Width = connectedSlot.getSlotLength();
    51                     setLoc(connectedSlot.Location.Center);
     57                    location.X = connectedSlot.startX;
     58                    Width = connectedSlot.endX - connectedSlot.startX;
     59                    Point slotCenter = connectedSlot.location.Center;
     60                    setYCenterTo(slotCenter.Y);
    5261                }
    53                 screen.Draw(PipeSprite, location);
     62                screen.Draw(CordSprite, location);
    5463            }
    5564            else
     
    6473                    location.Y, normWidth, location.Height);
    6574
    66                 screen.Draw(HeatedPipeSprite, redRect);
    67                 screen.Draw(PipeSprite, normRect);
     75                screen.Draw(ElectricCordSprite, redRect);
     76                screen.Draw(CordSprite, normRect);
    6877            }
    69            
     78
    7079            base.Draw(screen);
    7180        }
  • Code/oMaE/oMaE/Widgets/EnergyTransferWidgets/ETDoor.cs

    r126 r139  
    1414namespace oMaE.Widgets
    1515{
    16 
     16    public enum DoorType { Conduction, Fire, Electricity, Wind };
    1717   
    18     public class ETDoor : Slot
     18    public class ETDoor : ImageSlot
    1919    {
    2020        static Texture2D DoorSprite;
    2121
    22         public ETDoor(EnergyTransfer parent, int x, int y, Slot In)
     22        DoorType type;
     23
     24        public ETDoor(EnergyTransfer parent, int x, int y, Slot In, DoorType type)
    2325        {
    2426            width = 316/2;
     
    2628            this.parent = parent;
    2729            this.In = In;
    28             Location = new Rectangle(x, y - height/2, width, height);
    29             energyIn.Add(EnergyTypes.Heat);
     30            location = new Rectangle(x, y - height/2, width, height);
     31
     32            this.type = type;
     33
     34            switch (type)
     35            {
     36                case (DoorType.Conduction):
     37                    name = "Conduction Door";
     38                    toolTipText = "In: Heat";
     39                    energyIn.Add(EnergyTypes.Heat);
     40                    break;
     41                case (DoorType.Fire):
     42                    name = "Fire Door";
     43                    toolTipText = "In: Fire";
     44                    energyIn.Add(EnergyTypes.Fire);
     45                    break;
     46                case (DoorType.Wind):
     47                    name = "Wind Door";
     48                    toolTipText = "In: Wind";
     49                    energyIn.Add(EnergyTypes.Wind);
     50                    break;
     51                case (DoorType.Electricity):
     52                    toolTipText = "In: Electric";
     53                    name = "Wind Door";
     54                    energyIn.Add(EnergyTypes.Electric);
     55                    break;
     56            }
     57
     58        }
     59
     60        public override void Update(GameState gameState)
     61        {
     62            if (!gameState.Pressed(MouseButton.LEFT) && location.Contains(gameState.MousePoint))
     63            {
     64                displayToolTip = true;
     65            }
     66            else
     67            {
     68                displayToolTip = false;
     69            }
     70            base.Update(gameState);
    3071        }
    3172
    3273        public override void LoadContent(ContentManager Content)
    3374        {
    34             DoorSprite = Content.Load<Texture2D>("Sprites/conductiondoor");         
     75            switch (type)
     76            {
     77                case (DoorType.Conduction):
     78                    DoorSprite = Content.Load<Texture2D>("Sprites/conductiondoor");
     79                    break;
     80                case (DoorType.Fire):
     81                    DoorSprite = Content.Load<Texture2D>("Sprites/firedoor");
     82                    break;
     83                case (DoorType.Wind):
     84                    DoorSprite = Content.Load<Texture2D>("Sprites/winddoor");
     85                    break;
     86                case (DoorType.Electricity):
     87                    DoorSprite = Content.Load<Texture2D>("Sprites/electricdoor");
     88                    break;
     89            }                   
    3590            base.LoadContent(Content);
    3691        }
     
    4196        }
    4297
     98        protected void DrawToolTip(Screen2D screen)
     99        {
     100            Vector2 vec = screen.Measure(toolTipText);
     101            Vector2 stringLoc = new Vector2(location.X, location.Y - vec.Y);
     102            Rectangle textRectangle = new Rectangle((int)stringLoc.X, (int)stringLoc.Y, (int)vec.X, (int)vec.Y);
     103            screen.FillRectangle(textRectangle, Color.White);
     104            screen.DrawText(toolTipText, stringLoc, TextHorizontal.LEFT, TextVertical.TOP, Color.Black);
     105        }
     106
    43107        public override void Draw(Screen2D screen)
    44108        {
    45             screen.Draw(DoorSprite, Location);
     109            screen.Draw(DoorSprite, location);
    46110            base.Draw(screen);
    47111        }
  • Code/oMaE/oMaE/Widgets/EnergyTransferWidgets/Fire.cs

    r135 r139  
    1616
    1717   
    18     public class HeatSource : Slot
     18    public class Fire : ImageSlot
    1919    {
    20         static Texture2D HeatSourceSprite;
    21         static int HeatSourceWidth = 75;
    22         static int HeatSourceHeight = 75;
     20        static Texture2D FireSprite;
     21        static int FireWidth = 75;
     22        static int FireHeight = 75;
    2323       
    24         public HeatSource(EnergyTransfer parent, int x, int y, Slot Out)
     24        public Fire(EnergyTransfer parent, int x, int y, Slot Out)
    2525        {
    2626            this.Out = Out;
    2727            this.parent = parent;
    28             Location = new Rectangle(x - HeatSourceWidth / 2,
    29                 y - HeatSourceHeight / 2, HeatSourceWidth, HeatSourceHeight);
    30             energyOut = EnergyTypes.Heat;
    31         }
    32 
    33         public int EndX
    34         {
    35             get { return Location.X + Location.Width; }
     28            this.name = "Fire";
     29            toolTipText = "Out: Fire";
     30            location = new Rectangle(x - FireWidth / 2,
     31                y - FireHeight / 2, FireWidth, FireHeight);
     32            energyOut = EnergyTypes.Fire;
    3633        }
    3734
    3835        public override void LoadContent(ContentManager Content)
    3936        {
    40             //HeatSourceSprite = Content.Load<Texture2D>("Sprites/conductiondoor");         
     37            FireSprite = Content.Load<Texture2D>("Sprites/fire");         
    4138            base.LoadContent(Content);
    4239        }
     
    4441        public override void Draw(Screen2D screen)
    4542        {
    46             //screen.DrawR(HeatSourceSprite, location);
    47             screen.FillRectangle(Location, Color.Black);
     43            screen.Draw(FireSprite, location);
    4844            base.Draw(screen);
    4945        }
  • Code/oMaE/oMaE/Widgets/EnergyTransferWidgets/HeatSource.cs

    r126 r139  
    1616
    1717   
    18     public class HeatSource : Slot
     18    public class HeatSource : ImageSlot
    1919    {
    2020        static Texture2D HeatSourceSprite;
     
    2626            this.Out = Out;
    2727            this.parent = parent;
    28             Location = new Rectangle(x - HeatSourceWidth / 2,
     28            toolTipText = "Out: Heat";
     29            location = new Rectangle(x - HeatSourceWidth / 2,
    2930                y - HeatSourceHeight / 2, HeatSourceWidth, HeatSourceHeight);
    3031            energyOut = EnergyTypes.Heat;
    3132        }
    3233
    33         public int EndX
    34         {
    35             get { return Location.X + Location.Width; }
    36         }
    37 
    3834        public override void LoadContent(ContentManager Content)
    3935        {
    40             //HeatSourceSprite = Content.Load<Texture2D>("Sprites/conductiondoor");         
     36            HeatSourceSprite = Content.Load<Texture2D>("Sprites/heatsource");         
    4137            base.LoadContent(Content);
    4238        }
     
    4440        public override void Draw(Screen2D screen)
    4541        {
    46             //screen.DrawR(HeatSourceSprite, location);
    47             screen.FillRectangle(Location, Color.Black);
     42            screen.Draw(HeatSourceSprite, location);
    4843            base.Draw(screen);
    4944        }
  • Code/oMaE/oMaE/Widgets/EnergyTransferWidgets/ImageSlot.cs

    r135 r139  
    1616
    1717   
    18     public class HeatSource : Slot
     18    public class ImageSlot : Slot
    1919    {
    20         static Texture2D HeatSourceSprite;
    21         static int HeatSourceWidth = 75;
    22         static int HeatSourceHeight = 75;
     20        protected bool displayToolTip;
     21        protected string toolTipText;
     22
     23        protected int animateCounter;
     24        protected int AnimateTime;
    2325       
    24         public HeatSource(EnergyTransfer parent, int x, int y, Slot Out)
     26        public int EndX
    2527        {
    26             this.Out = Out;
    27             this.parent = parent;
    28             Location = new Rectangle(x - HeatSourceWidth / 2,
    29                 y - HeatSourceHeight / 2, HeatSourceWidth, HeatSourceHeight);
    30             energyOut = EnergyTypes.Heat;
     28            get { return location.X + location.Width; }
    3129        }
    3230
    33         public int EndX
     31        protected void DrawToolTip(Screen2D screen)
    3432        {
    35             get { return Location.X + Location.Width; }
     33            Vector2 vec = screen.Measure(toolTipText);
     34            Vector2 stringLoc = new Vector2(location.X, location.Y - vec.Y);
     35            Rectangle textRectangle = new Rectangle((int)stringLoc.X, (int)stringLoc.Y, (int)vec.X, (int)vec.Y);
     36            screen.FillRectangle(textRectangle, Color.White);
     37            screen.DrawText(toolTipText, stringLoc, TextHorizontal.LEFT, TextVertical.TOP, Color.Black);
    3638        }
    3739
    38         public override void LoadContent(ContentManager Content)
     40        public override void Update(GameState gameState)
    3941        {
    40             //HeatSourceSprite = Content.Load<Texture2D>("Sprites/conductiondoor");         
    41             base.LoadContent(Content);
     42            if (!gameState.Pressed(MouseButton.LEFT) && location.Contains(gameState.MousePoint))
     43            {
     44                displayToolTip = true;
     45            }
     46            else
     47            {
     48                displayToolTip = false;
     49            }
     50            base.Update(gameState);
    4251        }
     52
    4353
    4454        public override void Draw(Screen2D screen)
    4555        {
    46             //screen.DrawR(HeatSourceSprite, location);
    47             screen.FillRectangle(Location, Color.Black);
     56            if (displayToolTip)
     57            {
     58                DrawToolTip(screen);
     59            }
    4860            base.Draw(screen);
    4961        }
  • Code/oMaE/oMaE/Widgets/EnergyTransferWidgets/Outlet.cs

    r135 r139  
    1616
    1717   
    18     public class HeatSource : Slot
     18    public class Outlet : ImageSlot
    1919    {
    20         static Texture2D HeatSourceSprite;
    21         static int HeatSourceWidth = 75;
    22         static int HeatSourceHeight = 75;
     20        static Texture2D UnpluggedSprite;
     21        static Texture2D PluggedSprite;
     22        static int OutletWidth = 75;
     23        static int OutletHeight = 75;
     24        private bool plugged = false;
    2325       
    24         public HeatSource(EnergyTransfer parent, int x, int y, Slot Out)
     26        public Outlet(EnergyTransfer parent, int x, int y, Slot Out)
    2527        {
    2628            this.Out = Out;
    2729            this.parent = parent;
    28             Location = new Rectangle(x - HeatSourceWidth / 2,
    29                 y - HeatSourceHeight / 2, HeatSourceWidth, HeatSourceHeight);
    30             energyOut = EnergyTypes.Heat;
    31         }
    32 
    33         public int EndX
    34         {
    35             get { return Location.X + Location.Width; }
     30            name = "Outlet";
     31            toolTipText = "Out: Electricity";
     32            location = new Rectangle(x - OutletWidth / 2,
     33                y - OutletHeight / 2, OutletWidth, OutletHeight);
     34            energyOut = EnergyTypes.Electric;
    3635        }
    3736
    3837        public override void LoadContent(ContentManager Content)
    3938        {
    40             //HeatSourceSprite = Content.Load<Texture2D>("Sprites/conductiondoor");         
     39            UnpluggedSprite = Content.Load<Texture2D>("Sprites/outlet");
     40            PluggedSprite = Content.Load<Texture2D>("Sprites/outlet_plugged");
    4141            base.LoadContent(Content);
    4242        }
    4343
     44        public override void Update(GameState gamestate)
     45        {
     46            if (Out != null)
     47            {
     48                plugged = Out.name.Equals("Power Cord");
     49            }
     50            base.Update(gamestate);
     51        }
     52
     53
    4454        public override void Draw(Screen2D screen)
    4555        {
    46             //screen.DrawR(HeatSourceSprite, location);
    47             screen.FillRectangle(Location, Color.Black);
     56            if (plugged)
     57            {
     58                screen.Draw(PluggedSprite, location);
     59            }
     60            else
     61            {
     62                screen.Draw(UnpluggedSprite, location);
     63            }           
    4864            base.Draw(screen);
    4965        }
  • Code/oMaE/oMaE/Widgets/EnergyTransferWidgets/Piece.cs

    r126 r139  
    1717    public class Piece : GameObject
    1818    {
     19        public string name = "piece";
     20       
    1921        protected Rectangle location;
    2022        protected Rectangle origLocation;
    2123        protected bool dragging = false;
    2224        protected bool draggable;
     25
     26        protected bool displayToolTip;
     27        protected string toolTipText;
    2328
    2429        protected EnergyTransfer parent;
     
    5560        }
    5661
    57         public void setLoc(Point loc)
     62        public void setXCenterTo(int x)
    5863        {
    59             location.X = loc.X - Width / 2;
    60             location.Y = loc.Y - Height / 2;
     64            location.X = x - Width / 2;
    6165        }
    62 
    63         public void setLength(int length)
     66       
     67        public void setYCenterTo(int y)
    6468        {
    65             slotLength = length;
     69            location.Y = y - Height / 2;
    6670        }
    6771
     
    7983            connectedSlot.energyIn = new List<EnergyTypes>();
    8084            connectedSlot.energyOut = EnergyTypes.None;
     85            connectedSlot.name = "slot";
    8186            connectedSlot = null;
    8287        }
     
    8893            slot.energyIn = this.energyIn;
    8994            slot.energyOut = this.energyOut;
     95            slot.name = this.name;
    9096        }
     97
     98        protected void DrawToolTip(Screen2D screen)
     99        {
     100            Vector2 vec = screen.Measure(toolTipText);
     101            Vector2 stringLoc = new Vector2(location.X, location.Y - vec.Y);
     102            Rectangle textRectangle = new Rectangle((int)stringLoc.X, (int)stringLoc.Y, (int)vec.X, (int)vec.Y);
     103            screen.FillRectangle(textRectangle, Color.White);
     104            screen.DrawText(toolTipText, stringLoc, TextHorizontal.LEFT, TextVertical.TOP, Color.Black);
     105        }
     106
    91107
    92108        public override void Update(GameState gameState)
    93109        {
     110            if (connectedSlot == null)
     111            {
     112                animateCounter = -1;
     113            }
     114
    94115            if (animateCounter > 0)
    95116            {
    96117                animateCounter--;
    97118            }
    98             else if (animateCounter == 0)
     119            else if (animateCounter == 0 && connectedSlot != null)
    99120            {
    100                 connectedSlot.doneAnimating();
     121                connectedSlot.doneAnimating();               
    101122            }
    102123
    103             if (draggable && gameState.Pressed(MouseButton.LEFT) && new Rectangle((int)location.X, (int)location.Y, Width, Height).Contains(gameState.MousePoint))
     124            if (!dragging && !gameState.Pressed(MouseButton.LEFT) && location.Contains(gameState.MousePoint))
     125            {
     126                displayToolTip = true;
     127            }
     128            else
     129            {
     130                displayToolTip = false;
     131            }
     132
     133            if (draggable && gameState.Pressed(MouseButton.LEFT) && location.Contains(gameState.MousePoint))
    104134            {
    105135                if (connectedSlot != null)
  • Code/oMaE/oMaE/Widgets/EnergyTransferWidgets/Pipe.cs

    r126 r139  
    2323        public Pipe(EnergyTransfer parent, bool draggable, int x, int y)
    2424        {
    25             Width = 150;
     25            Width = 120;
    2626            Height = 40;
     27            toolTipText = "In: Heat     Out: Heat";
     28            name = "Conduction Rod";
    2729            this.parent = parent;
    2830            this.draggable = draggable;
     
    3335            animateCounter = -1;
    3436            AnimateTime = 200;
    35         }
     37        }     
    3638
    3739        public override void LoadContent(ContentManager Content)
     
    4446        public override void Draw(Screen2D screen)
    4547        {
     48            if (displayToolTip)
     49            {
     50                DrawToolTip(screen);
     51            }
     52
    4653            if (animateCounter < 0)
    4754            {
    4855                if (connectedSlot != null)
    4956                {
    50                     Width = connectedSlot.getSlotLength();
    51                     setLoc(connectedSlot.Location.Center);
     57                    location.X = connectedSlot.startX;
     58                    Width = connectedSlot.endX - connectedSlot.startX;
     59                    Point slotCenter = connectedSlot.location.Center;
     60                    setYCenterTo(slotCenter.Y);
    5261                }
    5362                screen.Draw(PipeSprite, location);
     
    6776                screen.Draw(PipeSprite, normRect);
    6877            }
    69            
     78
    7079            base.Draw(screen);
    7180        }
  • Code/oMaE/oMaE/Widgets/EnergyTransferWidgets/Slot.cs

    r126 r139  
    1818    public class Slot : GameObject
    1919    {
    20         public Rectangle Location;
     20        public Rectangle location;
    2121        public EnergyTransfer parent;
    2222
     
    2929        public bool animating = false;
    3030
     31        public string name = "slot";
     32
    3133        protected int height;
    3234        protected int width;
     
    3436        public Vector2 getVec()
    3537        {
    36             return new Vector2(Location.X, Location.Y);
     38            return new Vector2(location.X, location.Y);
    3739        }
    3840
  • Code/oMaE/oMaE/Widgets/EnergyTransferWidgets/WindMill.cs

    r135 r139  
    1616
    1717   
    18     public class Pipe : Piece
     18    public class WindMill : Piece
    1919    {
    20         static Texture2D PipeSprite;
    21         static Texture2D HeatedPipeSprite;
     20        static Texture2D CordSprite;
     21        static Texture2D WindMillSprite;
    2222
    23         public Pipe(EnergyTransfer parent, bool draggable, int x, int y)
     23        public static int connectedWidth = 295 / 3;
     24        public static int connectedHeight = 536 / 3;
     25       
     26
     27        public WindMill(EnergyTransfer parent, bool draggable, int x, int y)
    2428        {
    25             Width = 150;
    26             Height = 40;
     29            Width = 295/6;
     30            Height = 536/6;
     31            toolTipText = "In: Wind     Out: Electric";
     32            name = "Windmill";
    2733            this.parent = parent;
    2834            this.draggable = draggable;
    29             location = new Rectangle(x, y, Width, Height);
    30             origLocation = new Rectangle(x, y, Width, Height);
    31             energyIn.Add(EnergyTypes.Heat);
    32             energyOut = EnergyTypes.Heat;
     35            origLocation = new Rectangle(x, y-15, Width, Height);
     36            location = origLocation;
     37            energyIn.Add(EnergyTypes.Wind);
     38            energyOut = EnergyTypes.Electric;
    3339            animateCounter = -1;
    3440            AnimateTime = 200;
    35         }
     41        }     
    3642
    3743        public override void LoadContent(ContentManager Content)
    3844        {
    39             PipeSprite = Content.Load<Texture2D>("Sprites/rodseg");
    40             HeatedPipeSprite = Content.Load<Texture2D>("Sprites/heatedrodseg");
     45            CordSprite = Content.Load<Texture2D>("Sprites/powercable");
     46            WindMillSprite = Content.Load<Texture2D>("Sprites/windmill");
    4147            base.LoadContent(Content);
    4248        }
     
    4450        public override void Draw(Screen2D screen)
    4551        {
    46             if (animateCounter < 0)
     52            if (displayToolTip)
    4753            {
    48                 if (connectedSlot != null)
    49                 {
    50                     Width = connectedSlot.getSlotLength();
    51                     setLoc(connectedSlot.Location.Center);
    52                 }
    53                 screen.Draw(PipeSprite, location);
     54                DrawToolTip(screen);
    5455            }
    55             else
     56
     57            if (connectedSlot != null)
    5658            {
    57                 int timePassed = AnimateTime - animateCounter;
    58                 int redWidth = (timePassed * location.Width) / AnimateTime;
    59                 int normWidth = (animateCounter * location.Width) / AnimateTime; ;
     59                Width = connectedWidth;
     60                Height = connectedHeight;               
     61                Point slotCenter = connectedSlot.location.Center;
     62                setYCenterTo(slotCenter.Y);
     63                setXCenterTo(slotCenter.X);
     64                int startCordX = connectedSlot.location.X + ConnectableSlot.ConnectableWidth;
     65                Rectangle cordRect = new Rectangle(startCordX, slotCenter.Y - 10,
     66                    connectedSlot.endX - startCordX, 20);
     67                screen.Draw(CordSprite, cordRect);
     68            }
     69            screen.Draw(WindMillSprite, location);
    6070
    61                 Rectangle redRect = new Rectangle(location.X, location.Y,
    62                     redWidth, location.Height);
    63                 Rectangle normRect = new Rectangle(location.X + redWidth,
    64                     location.Y, normWidth, location.Height);
    65 
    66                 screen.Draw(HeatedPipeSprite, redRect);
    67                 screen.Draw(PipeSprite, normRect);
    68             }
    69            
    7071            base.Draw(screen);
    7172        }
  • Code/oMaE/oMaE/Widgets/EnergyTransferWidgets/WindSource.cs

    r135 r139  
    1616
    1717   
    18     public class HeatSource : Slot
     18    public class WindSource : ImageSlot
    1919    {
    20         static Texture2D HeatSourceSprite;
    21         static int HeatSourceWidth = 75;
    22         static int HeatSourceHeight = 75;
     20        static Texture2D WindSourceSprite1;
     21        static Texture2D WindSourceSprite2;
     22        static Texture2D WindSourceSprite3;
     23        static int WindSourceWidth = 75;
     24        static int WindSourceHeight = 75;
    2325       
    24         public HeatSource(EnergyTransfer parent, int x, int y, Slot Out)
     26        public WindSource(EnergyTransfer parent, int x, int y, Slot Out)
    2527        {
    2628            this.Out = Out;
    2729            this.parent = parent;
    28             Location = new Rectangle(x - HeatSourceWidth / 2,
    29                 y - HeatSourceHeight / 2, HeatSourceWidth, HeatSourceHeight);
    30             energyOut = EnergyTypes.Heat;
    31         }
    32 
    33         public int EndX
    34         {
    35             get { return Location.X + Location.Width; }
     30            toolTipText = "Out: Wind";
     31            name = "Wind Source";
     32            location = new Rectangle(x - WindSourceWidth / 2,
     33                y - WindSourceHeight / 2, WindSourceWidth, WindSourceHeight);
     34            energyOut = EnergyTypes.Wind;
    3635        }
    3736
    3837        public override void LoadContent(ContentManager Content)
    3938        {
    40             //HeatSourceSprite = Content.Load<Texture2D>("Sprites/conductiondoor");         
     39            WindSourceSprite1 = Content.Load<Texture2D>("Sprites/windsource");
     40            WindSourceSprite2 = Content.Load<Texture2D>("Sprites/windsource3");
     41            WindSourceSprite3 = Content.Load<Texture2D>("Sprites/windsource2"); 
    4142            base.LoadContent(Content);
     43        }
     44
     45        public override void Update(GameState gamestate)
     46        {
     47            if (animating)
     48            {
     49                animateCounter = ++animateCounter % 3;
     50                base.Update();
     51            }
     52        }
     53
     54        public override void animate()
     55        {
     56            animating = true;
     57            if (Out != null)
     58                Out.animate();
    4259        }
    4360
    4461        public override void Draw(Screen2D screen)
    4562        {
    46             //screen.DrawR(HeatSourceSprite, location);
    47             screen.FillRectangle(Location, Color.Black);
     63            if(animating)
     64            {
     65                switch (animateCounter)
     66                {
     67                    case(1):
     68                        screen.Draw(WindSourceSprite1, location);
     69                        break;
     70                    case (2):
     71                        screen.Draw(WindSourceSprite2, location);
     72                        break;
     73                    case (3):
     74                        screen.Draw(WindSourceSprite3, location);
     75                        break;
     76                }           
     77            }
     78            else
     79            {
     80                screen.Draw(WindSourceSprite1, location);
     81            }           
    4882            base.Draw(screen);
    4983        }
  • Code/oMaE/oMaE/Widgets/EnergyTransferWidgets/Wood.cs

    r135 r139  
    1616
    1717   
    18     public class Pipe : Piece
     18    public class Wood : Piece
    1919    {
    20         static Texture2D PipeSprite;
    21         static Texture2D HeatedPipeSprite;
     20        static Texture2D WoodSprite;
     21        static Texture2D BurntWoodSprite;
     22        static Texture2D FireSprite;
    2223
    23         public Pipe(EnergyTransfer parent, bool draggable, int x, int y)
     24        public Wood(EnergyTransfer parent, bool draggable, int x, int y)
    2425        {
    25             Width = 150;
     26            Width = 120;
    2627            Height = 40;
    2728            this.parent = parent;
    2829            this.draggable = draggable;
     30            toolTipText = "In: Fire     Out: Fire";
     31            name = "Wood Rod";
    2932            location = new Rectangle(x, y, Width, Height);
    3033            origLocation = new Rectangle(x, y, Width, Height);
    31             energyIn.Add(EnergyTypes.Heat);
    32             energyOut = EnergyTypes.Heat;
     34            energyIn.Add(EnergyTypes.Fire);
     35            energyOut = EnergyTypes.Fire;
    3336            animateCounter = -1;
    3437            AnimateTime = 200;
     
    3740        public override void LoadContent(ContentManager Content)
    3841        {
    39             PipeSprite = Content.Load<Texture2D>("Sprites/rodseg");
    40             HeatedPipeSprite = Content.Load<Texture2D>("Sprites/heatedrodseg");
     42            WoodSprite = Content.Load<Texture2D>("Sprites/woodbar");
     43            BurntWoodSprite = Content.Load<Texture2D>("Sprites/burntwood");
     44            FireSprite = Content.Load<Texture2D>("Sprites/fire");
    4145            base.LoadContent(Content);
    4246        }
     
    4448        public override void Draw(Screen2D screen)
    4549        {
     50            if (displayToolTip)
     51            {
     52                DrawToolTip(screen);
     53            }
     54           
    4655            if (animateCounter < 0)
    4756            {
    4857                if (connectedSlot != null)
    4958                {
    50                     Width = connectedSlot.getSlotLength();
    51                     setLoc(connectedSlot.Location.Center);
     59                    location.X = connectedSlot.startX;
     60                    Width = connectedSlot.endX - connectedSlot.startX;
     61                    Point slotCenter = connectedSlot.location.Center;
     62                    setYCenterTo(slotCenter.Y);
    5263                }
    53                 screen.Draw(PipeSprite, location);
     64                screen.Draw(WoodSprite, location);
    5465            }
    5566            else
    5667            {
    5768                int timePassed = AnimateTime - animateCounter;
    58                 int redWidth = (timePassed * location.Width) / AnimateTime;
     69                int burntWidth = (timePassed * location.Width) / AnimateTime;
    5970                int normWidth = (animateCounter * location.Width) / AnimateTime; ;
    6071
    61                 Rectangle redRect = new Rectangle(location.X, location.Y,
    62                     redWidth, location.Height);
    63                 Rectangle normRect = new Rectangle(location.X + redWidth,
     72                Rectangle burntRect = new Rectangle(location.X, location.Y,
     73                    burntWidth, location.Height);
     74                Rectangle normRect = new Rectangle(location.X + burntWidth,
    6475                    location.Y, normWidth, location.Height);
     76                Rectangle fireRect = new Rectangle(location.X + burntWidth - 20,
     77                    location.Y, 40, location.Height);
    6578
    66                 screen.Draw(HeatedPipeSprite, redRect);
    67                 screen.Draw(PipeSprite, normRect);
     79                screen.Draw(BurntWoodSprite, burntRect);               
     80                screen.Draw(WoodSprite, normRect);
     81                if (normWidth > 0)
     82                {
     83                    screen.Draw(FireSprite, fireRect);
     84                }
    6885            }
    6986           
Note: See TracChangeset for help on using the changeset viewer.