Galaxy: A few more tweaks to the Radius generation
[GalaxyGenerator.git] / Star.cs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
using System;
using System.IO;
using System.Drawing;
 
namespace GalaxyGenerator
{
        public class Star
        {
                public Star(double x, double y, double z)
                {
                        Random rand = GlobalParameters.rand;
                        
                        coords = new CartesianCoords(x, y, z);
                        
                        if (rand.Next(0, 1) == 0) {
                                ColorIndex = (uint)rand.Next(0, ValidColors.Length - 1);
                        }
                        else
                        {
                                ColorIndex = 0;
                        }
                }
                public Star(Tuple myTuple) : this(myTuple.p1, myTuple.p2, myTuple.p3) {}
                public Star(CartesianCoords myCoords) : this(myCoords.getTuple()) {}
                public Star() : this(0,0,0) {}
                
                public CartesianCoords getCoords()
                {
                        return coords;
                }
                
                public void setCoords(double x, double y, double z)
                {
                        coords.setX(x);
                        coords.setY(y);
                        coords.setZ(z);
                }
                public void setCoords(Tuple myTuple)
                {
                        setCoords (myTuple.p1, myTuple.p2, myTuple.p3);
                }
                public void setCoords(CartesianCoords myCoords)
                {
                        setCoords(myCoords.getTuple());
                }
                
                public UInt64 getID()
                {
                        return id;
                }
                
                public void setID(UInt64 newID)
                {
                        id = newID;
                }
                
                public Color getColor()
                {
                        return ValidColors[ColorIndex];
                }
                
                public void setColorIndex(uint NewIndex)
                {
                        ColorIndex = NewIndex;
                }
 
                /// <summary>
                /// Writes a star to the specified stream.
                /// </summary>
                /// <param name='stream'>
                /// Save file stream passed from Galaxy.Save.
                /// </param>
                /// 
                public void Save(FileStream stream)
                {
                        stream.Write(BitConverter.GetBytes(SaveCode), 0, sizeof(UInt16));
                        stream.Write(BitConverter.GetBytes(id), 0, sizeof(UInt64));
                        stream.Write(BitConverter.GetBytes(coords.getX()), 0, sizeof(double));
                        stream.Write(BitConverter.GetBytes(coords.getY()), 0, sizeof(double));
                        stream.Write(BitConverter.GetBytes(coords.getZ()), 0, sizeof(double));
                        stream.Write(BitConverter.GetBytes(ColorIndex), 0, sizeof(uint));
                }
 
                /// <summary>
                /// Creates a new star from data in the specified stream at the specified offset.
                /// </summary>
                /// <param name='stream'>
                /// Stream from Galaxy.Load.
                /// </param>
                /// <param name='offset'>
                /// Offset from Galaxy.Load.
                /// </param>
                public static Star Load(byte[] stream, ref int offset)
                {
                        Star star = new Star();
                        UInt16 ReadCode = BitConverter.ToUInt16(stream, offset);
                        if (ReadCode != SaveCode) { throw new Exception("we can't handle anything other than stars yet"); }
                        offset += sizeof(UInt16);
                        UInt64 ReadID = BitConverter.ToUInt64(stream, offset);
                        offset += sizeof(UInt64);
                        double ReadX = BitConverter.ToDouble(stream, offset);
                        offset += sizeof(double);
                        double ReadY = BitConverter.ToDouble(stream, offset);
                        offset += sizeof(double);
                        double ReadZ = BitConverter.ToDouble(stream, offset);
                        offset += sizeof(double);
                        uint ReadColorIndex = BitConverter.ToUInt32(stream, offset);
                        offset += sizeof(uint);
                        
                        star.setID(ReadID);
                        star.setCoords(ReadX, ReadY, ReadZ);
                        star.setColorIndex(ReadColorIndex);
 
                        return star;
                }
                
                private CartesianCoords coords = null;
                private UInt64 id;
                private uint ColorIndex;
                private static UInt16 SaveCode = GlobalParameters.SaveCodes["Star"];
                private static Color[] ValidColors = new Color[] {Color.White, Color.Yellow, Color.Red, Color.Orange, Color.OrangeRed, Color.LightBlue, Color.Violet, Color.Blue, Color.BlueViolet, Color.Green, Color.YellowGreen};
        }
}