Changeset 139

Show
Ignore:
Timestamp:
04/24/2012 12:24:20 PM (2 years ago)
Author:
zpurdy
Message:

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

Location:
Code/oMaE/oMaE/Widgets/EnergyTransferWidgets
Files:
6 modified
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

    r126 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

    r126 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

    r126 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

    r126 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

    r126 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

    r126 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

    r126 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