public void ApplyTilt(Tilt tilt)
{
if(tilt != Tilt.none)
_tilt = tilt;
else
_tilt = Tilt.none;
}
// Start is called before the first frame update
void Start()
{
inMiddleOfAttack = false;
inMiddleOfJump = false;
rb = GetComponent <Rigidbody>();
ks = Controls.GetKeyset(controls);
if (rotationAxis.Equals(axis.x))
{
rotationVector = Vector3.right;
}
else if (rotationAxis.Equals(axis.y))
{
rotationVector = Vector3.up;
}
else if (rotationAxis.Equals(axis.z))
{
rotationVector = Vector3.forward;
}
rb.mass = mass;
//deltaRotation = Quaternion.Euler(rotationVector * angularVelocity * Time.deltaTime);
/* No amount of angular velocity could generate enough force to keep the blade stable while spinning.
* So used this to keep the blade stable.
*/
rb.freezeRotation = true;
Physics.gravity = Vector3.down * jumpGravity;
initRotation = transform.rotation;
dashAbility = new DashAbility();
dashAbility.dashState = DashState.Ready;
tilt = new Tilt(initRotation.eulerAngles.x, maxTilt);
//Rotating the blade every frame to keep it spinning.
bladeSpin = Quaternion.Euler(Vector3.forward * angularVelocity * Time.deltaTime);
}
public virtual void SaveToXML(XmlElement objOrbit)
{
var nfi = System.Globalization.NumberFormatInfo.InvariantInfo;
var xePlanet = objOrbit.OwnerDocument.CreateElement("Planet");
objOrbit.AppendChild(xePlanet);
Common.CreateTextNode(xePlanet, "Type", PlanetType.ToString());
Common.CreateTextNode(xePlanet, "Dense", Dense.ToString());
Common.CreateTextNode(xePlanet, "Mass", Mass.ToString());
Common.CreateTextNode(xePlanet, "Gravity", Grav.ToString());
Common.CreateTextNode(xePlanet, "Pressure", Pressure.ToString());
Common.CreateTextNode(xePlanet, "MaxPop", Maxpop.ToString());
Common.CreateTextNode(xePlanet, "OrbitRange", OrbitRange.ToString());
Common.CreateTextNode(xePlanet, "OrbitNumber", OrbitNumber.ToString());
Common.CreateTextNode(xePlanet, "Tilt", Tilt.ToString());
Common.CreateTextNode(xePlanet, "Ecc", Ecc.ToString());
Common.CreateTextNode(xePlanet, "Rotation", Rotation.ToString());
Common.CreateTextNode(xePlanet, "TidallyLocked", TidallyLocked.ToString());
Common.CreateTextNode(xePlanet, "Temp", Temp.ToString());
Common.CreateTextNode(xePlanet, "Diameter", Diameter.ToString());
Common.CreateTextNode(xePlanet, "NumSats", Satellites.Count.ToString());
Common.CreateTextNode(xePlanet, "Mainworld", MainWorld.ToString());
Common.CreateTextNode(xePlanet, "NormalUWP", Normal.DisplayString(PlanetType, Diameter));
Common.CreateTextNode(xePlanet, "CollapseUWP", Collapse.DisplayString(PlanetType, Diameter));
Common.CreateTextNode(xePlanet, "Life", Life.ToString());
Common.CreateTextNode(xePlanet, "LifeFactor", LifeFactor.ToString());
Common.CreateTextNode(xePlanet, "Name", Name);
var xeChild = objOrbit.OwnerDocument.CreateElement("Temperature");
for (var i = 0; i < (Constants.NUM_HEX_ROWS * 2) - 1; i += 2)
{
var xeTemp = objOrbit.OwnerDocument.CreateElement("Row" + (i / 2 + 1).ToString());
Common.CreateTextNode(xeTemp, "Summer", Summer[i].ToString("N", nfi) + "/" + Summer[i + 1].ToString("N", nfi));
Common.CreateTextNode(xeTemp, "Fall", Fall[i].ToString("N", nfi) + "/" + Fall[i + 1].ToString("N", nfi));
Common.CreateTextNode(xeTemp, "Winter", Winter[i].ToString("N", nfi) + "/" + Winter[i + 1].ToString("N", nfi));
xeChild.AppendChild(xeTemp);
}
xePlanet.AppendChild(xeChild);
if (Life)
{
xeChild = objOrbit.OwnerDocument.CreateElement("AnimalEncounters");
TableGenerator.WriteToXML(xeChild);
xePlanet.AppendChild(xeChild);
}
Normal.SaveToXML(xePlanet);
Collapse.SaveToXML(xePlanet);
foreach (var satellite in Satellites)
{
satellite.SaveToXML(xePlanet);
}
}
private void MouseMovement()
{
bool playerOnLeft = (currentPos % 2) == 0;
if (Input.GetAxis("Mouse X") > 0 && playerOnLeft && Input.GetMouseButton(0))
{
pushEffect.SetActive(true);
pushSound.Play();
Debug.Log("activated");
//trophy move right
if (currentPos == 0)
{
//get the first trophy and topple right
GameObject firstTrophy = GameObject.Find("Trophy 1");
Tilt script = firstTrophy.GetComponent <Tilt>();
script.toppleRight(noOfHits);
}
else if (currentPos == 2)
{
//toople right 2nd trophy
GameObject secondTrophy = GameObject.Find("Trophy 2");
Tilt script = secondTrophy.GetComponent <Tilt>();
script.toppleRight(noOfHits);
}
else if (currentPos == 4)
{
//toople right 3rd trophy
GameObject trophyThird = GameObject.Find("Trophy 3");
trophyThird.GetComponent <Tilt>().toppleRight(noOfHits);
}
}
if (Input.GetAxis("Mouse X") < 0 && !playerOnLeft && Input.GetMouseButton(0))
{
pushEffect.SetActive(true);
pushSound.Play();
//trophy move left
if (currentPos == 1)
{
//get the first trophy and topple right
GameObject firstTrophy = GameObject.Find("Trophy 1");
firstTrophy.GetComponent <Tilt>().toppleLeft(noOfHits);
}
else if (currentPos == 3)
{
//toople left 2nd trophy
GameObject secTrophy = GameObject.Find("Trophy 2");
secTrophy.GetComponent <Tilt>().toppleLeft(noOfHits);
}
else if (currentPos == 5)
{
//toople left 3rd trophy
GameObject thirdTrophy = GameObject.Find("Trophy 3");
thirdTrophy.GetComponent <Tilt>().toppleLeft(noOfHits);
}
}
}
void OnTriggerEnter2D(Collider2D col)
{
Tilt.SetYouWinToTrue();
if (col.name == "Goal")
{
Destroy(gameObject, .4f);
Debug.Log("You Win!");
}
}
public virtual void SaveToXml(System.Xml.XmlTextWriter xmlWriter)
{
xmlWriter.WriteStartElement("ReferenceFrame");
xmlWriter.WriteAttributeString("Name", Name);
xmlWriter.WriteAttributeString("Parent", Parent);
xmlWriter.WriteAttributeString("ReferenceFrameType", ReferenceFrameType.ToString());
xmlWriter.WriteAttributeString("Reference", Reference.ToString());
xmlWriter.WriteAttributeString("ParentsRoationalBase", ParentsRoationalBase.ToString());
xmlWriter.WriteAttributeString("MeanRadius", MeanRadius.ToString());
xmlWriter.WriteAttributeString("Oblateness", Oblateness.ToString());
xmlWriter.WriteAttributeString("Heading", Heading.ToString());
xmlWriter.WriteAttributeString("Pitch", Pitch.ToString());
xmlWriter.WriteAttributeString("Roll", Roll.ToString());
xmlWriter.WriteAttributeString("Scale", Scale.ToString());
xmlWriter.WriteAttributeString("Tilt", Tilt.ToString());
xmlWriter.WriteAttributeString("Translation", Translation.ToString());
if (ReferenceFrameType == ReferenceFrameTypes.FixedSherical)
{
xmlWriter.WriteAttributeString("Lat", Lat.ToString());
xmlWriter.WriteAttributeString("Lng", Lng.ToString());
xmlWriter.WriteAttributeString("Altitude", Altitude.ToString());
}
xmlWriter.WriteAttributeString("RotationalPeriod", RotationalPeriod.ToString());
xmlWriter.WriteAttributeString("ZeroRotationDate", ZeroRotationDate.ToString());
xmlWriter.WriteAttributeString("RepresentativeColor", SavedColor.Save(RepresentativeColor));
xmlWriter.WriteAttributeString("ShowAsPoint", ShowAsPoint.ToString());
xmlWriter.WriteAttributeString("ShowOrbitPath", ShowOrbitPath.ToString());
xmlWriter.WriteAttributeString("StationKeeping", StationKeeping.ToString());
if (ReferenceFrameType == ReferenceFrameTypes.Orbital)
{
xmlWriter.WriteAttributeString("SemiMajorAxis", SemiMajorAxis.ToString());
xmlWriter.WriteAttributeString("SemiMajorAxisScale", this.SemiMajorAxisUnits.ToString());
xmlWriter.WriteAttributeString("Eccentricity", Eccentricity.ToString());
xmlWriter.WriteAttributeString("Inclination", Inclination.ToString());
xmlWriter.WriteAttributeString("ArgumentOfPeriapsis", ArgumentOfPeriapsis.ToString());
xmlWriter.WriteAttributeString("LongitudeOfAscendingNode", LongitudeOfAscendingNode.ToString());
xmlWriter.WriteAttributeString("MeanAnomolyAtEpoch", MeanAnomolyAtEpoch.ToString());
xmlWriter.WriteAttributeString("MeanDailyMotion", MeanDailyMotion.ToString());
xmlWriter.WriteAttributeString("Epoch", Epoch.ToString());
}
if (ReferenceFrameType == ReferenceFrameTypes.Trajectory)
{
xmlWriter.WriteStartElement("Trajectory");
foreach (TrajectorySample sample in Trajectory)
{
string data = sample.ToString();
xmlWriter.WriteElementString("Sample", data);
}
xmlWriter.WriteEndElement();
}
xmlWriter.WriteEndElement();
}
public static byte[] CameraTilt(uint deviceAddress, Tilt action, uint speed)
{
if (speed < TiltSpeedMax)
{
speed = TiltSpeedMax;
}
return(Message.GetMessage(deviceAddress, 0x00, (byte)action, 0x00, (byte)speed));
}
public ActionResult <MartinTiltFormulaInducedCylinderModel> MartinTiltFormulaInducedCylinder(MartinTiltFormulaInducedCylinderModel cylinder)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
cylinder.Result = Tilt.MartinTiltFormulaInducedCylinder(cylinder.NewSpherePower, cylinder.DegreesOfTilt);
return(cylinder);
}
public ActionResult <MartinTiltFormulaSphereModel> MartinTiltFormulaSphere(MartinTiltFormulaSphereModel sphere)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
sphere.Result = Tilt.MartinTiltFormulaSphere(sphere.OriginalSpherePower, sphere.DegreesOfTilt, sphere.Index);
return(sphere);
}
public static Tilt ProcessData(JSONNode data)
{
Tilt processedData = new Tilt();
processedData.pitch = data ["pitch"];
processedData.roll = data ["roll"];
processedData.variance = data ["variance"];
return(processedData);
}
private void Window_KeyDown(object sender, System.Windows.Input.KeyEventArgs e)
{
if (e.Key == System.Windows.Input.Key.Up)
{
Tilt.TiltUp(ksensor);
}
if (e.Key == System.Windows.Input.Key.Down)
{
Tilt.TiltDown(ksensor);
}
}
/// <summary>
/// Sets the path of one of the background images.
/// </summary>
/// <param name="orientation">The orientation.</param>
/// <param name="path">The path to the image file.</param>
internal static void Execute(Tilt orientation, string path)
{
if (orientation == Tilt.Vertical)
{
AppState.Instance.VerticalBackgroundPath = path;
}
else if (orientation == Tilt.Horizontal)
{
AppState.Instance.HorizontalBackgroundPath = path;
}
}
void OnTriggerEnter2D(Collider2D col)
{
Tilt.setIsDeadTrue();
{
if (col.name == "Death")
{
Destroy(gameObject, .4f);
Debug.Log("You Loose!");
}
}
}
public void ApplyTilt(Tilt tilt)
{
if (tilt != Tilt.none)
{
_tilt = tilt;
}
else
{
_tilt = Tilt.none;
}
}
public bool Equals(CameraSector other)
{
if (ReferenceEquals(null, other))
{
return(false);
}
if (ReferenceEquals(this, other))
{
return(true);
}
return(Pan.Equals(other.Pan) && Tilt.Equals(other.Tilt));
}
public static Tilt GetTiltOfLastDynamicState(JSONNode data)
{
foreach (JSONNode state in data.Children)
{
if (int.Parse(state ["first_id"]) > maxFirstID)
{
maxFirstID = int.Parse(state ["first_id"]);
maxData = state;
}
}
return(Tilt.ProcessData(maxData ["tilt"]));
}
//feed the filters with data input
public void Feed(double input)
{
if (Reset)
{
//reset filter memory
Trend.output = input;
Denoise.output = input;
Tilt.output = input;
Reset = false;
}
Trend.Feed(input); Denoise.Feed(input); Tilt.Feed(input);
Smooth = Tilt.output - Trend.output;
Sudden = Denoise.output - Tilt.output;
}
public static Tilt GetTilt(JSONNode data)
{
Tilt newTilt = new Tilt();
foreach (JSONNode baseStation in data.Children)
{
if (Config.VerifySerialNumber(baseStation ["config"]))
{
newTilt = DynamicState.GetTiltOfLastDynamicState(baseStation["dynamic_states"]);
}
}
return(newTilt);
}
public static Universe GetUniverse(JSONNode universeData, string universeID)
{
Universe universe = new Universe();
Tilt tilt = new Tilt();
foreach (JSONNode node in universeData.Children)
{
if (ChaperoneCalibrator.SplitQuote(node ["id"]) == universeID)
{
universe = ProcessData(node);
}
}
return(universe);
}
public Universe ProcessData(JSONNode data)
{
Universe processedData = new Universe();
string base_stationsD = data ["base_stations"];
processedData.id = SplitQuote(data["id"]);
if (data ["lastChaperoneCommit"] != null)
{
processedData.lastChaperoneCommit = SplitQuote(data ["lastChaperoneCommit"]);
}
JSONNode tiltD = data ["tilt"];
processedData.tilt = Tilt.ProcessData(tiltD);
return(processedData);
}
public void UpdateMessageAddress(string messageaddress)
{
MessageAddress = messageaddress;
FileSelector.UpdateMessageAddress(MessageAddress);
Brightness.UpdateMessageAddress(String.Format("{0}{1}/", MessageAddress, nameof(Brightness)));
Contrast.UpdateMessageAddress(String.Format("{0}{1}/", MessageAddress, nameof(Contrast)));
Invert.UpdateMessageAddress(String.Format("{0}{1}/", MessageAddress, nameof(Invert)));
Hue.UpdateMessageAddress(String.Format("{0}{1}/", MessageAddress, nameof(Hue)));
Saturation.UpdateMessageAddress(String.Format("{0}{1}/", MessageAddress, nameof(Saturation)));
Luminosity.UpdateMessageAddress(String.Format("{0}{1}/", MessageAddress, nameof(Luminosity)));
Keying.UpdateMessageAddress(String.Format("{0}{1}/", MessageAddress, nameof(Keying)));
Scale.UpdateMessageAddress(String.Format("{0}{1}/", MessageAddress, nameof(Scale)));
Rotate.UpdateMessageAddress(String.Format("{0}{1}/", MessageAddress, nameof(Rotate)));
Pan.UpdateMessageAddress(String.Format("{0}{1}/", MessageAddress, nameof(Pan)));
Tilt.UpdateMessageAddress(String.Format("{0}{1}/", MessageAddress, nameof(Tilt)));
}
//Get universe pitch & roll from lighthousedb.json
double[] GetUniverseOffset()
{
StreamReader reader = new StreamReader(filePath);
string json = reader.ReadToEnd();
var data = JSON.Parse(json);
double[] universeTiltData = new double[3];
Tilt universeTilt = Universe.GetTilt(data ["known_universes"], currentUniverseID);
Tilt baseTilt = BaseStation.GetTilt(data["base_stations"]);
universeTiltData [0] = universeTilt.pitch;
universeTiltData [1] = universeTilt.roll;
universeTiltData [2] = universeTilt.variance;
return(universeTiltData);
}
public static Tilt GetTilt(JSONNode universeData, string universeID)
{
Universe universe = new Universe();
Tilt tilt = new Tilt();
foreach (JSONNode node in universeData.Children)
{
if (ChaperoneCalibrator.SplitQuote(node ["id"]) == universeID)
{
universe = ProcessData(node);
tilt.pitch = universe.tilt.pitch;
tilt.roll = universe.tilt.roll;
tilt.variance = universe.tilt.variance;
Debug.Log("Obtained offset from universe " + universe.id + " : (" + tilt.pitch + "," + tilt.roll + ")");
}
}
return(tilt);
}
public static int GetLayer(double x, double y, double z)
{
double zshift = Tilt.GetValue(x, y, z);
z += zshift;
double l_offset = z - layerStart[0];
if (l_offset < 0)
{
return(0);
}
int layer = (int)Math.Floor(l_offset / layerSpacing);
if (layer >= layerStart.Length)
{
return(layerStart.Length - 1);
}
return(layer);
}
public override XmlNode ToXml(XmlNode parent)
{
XmlNode result = parent.OwnerDocument.CreateNode(XmlNodeType.Element, "Camera", string.Empty);
//create child nodes
XmlNode nodLong = parent.OwnerDocument.CreateNode(XmlNodeType.Element, "longitude", string.Empty);
nodLong.InnerText = Longitude.ToString();
result.AppendChild(nodLong);
XmlNode nodLat = parent.OwnerDocument.CreateNode(XmlNodeType.Element, "latitude", string.Empty);
nodLat.InnerText = Latitude.ToString();
result.AppendChild(nodLat);
XmlNode nodAlt = parent.OwnerDocument.CreateNode(XmlNodeType.Element, "altitude", string.Empty);
nodAlt.InnerText = Altitude.ToString();
result.AppendChild(nodAlt);
XmlNode nodRoll = parent.OwnerDocument.CreateNode(XmlNodeType.Element, "roll", string.Empty);
nodRoll.InnerText = Roll.ToString();
result.AppendChild(nodRoll);
XmlNode nodTilt = parent.OwnerDocument.CreateNode(XmlNodeType.Element, "tilt", string.Empty);
nodTilt.InnerText = Tilt.ToString();
result.AppendChild(nodTilt);
XmlNode nodHeading = parent.OwnerDocument.CreateNode(XmlNodeType.Element, "heading", string.Empty);
nodHeading.InnerText = Heading.ToString();
result.AppendChild(nodHeading);
XmlNode nodAltitudeMode = parent.OwnerDocument.CreateNode(XmlNodeType.Element, "altitudeMode", string.Empty);
nodAltitudeMode.InnerText = AltitudeMode;
result.AppendChild(nodAltitudeMode);
return(result);
}
void FixedUpdate()
{
staticRotation.x += Tilt.makeMotionDiff(staticRotation.x);
staticRotation.y += Pan.makeMotionDiff(staticRotation.y);
dynamicPosition.x += CraneH.makeMotionDiff(dynamicPosition.x);
dynamicPosition.y += CraneV.makeMotionDiff(dynamicPosition.y);
dynamicPosition.z += Zoom.makeMotionDiff(dynamicPosition.z);
trackPosition = Track.MakeTrackingMotionDiffP();
transform.position = dynamicPosition + trackPosition;
if (Track.isTracking)
{
transform.LookAt(Track.target.transform, Vector3.up);
transform.rotation = Quaternion.Euler(trackRotation + staticRotation + transform.rotation.eulerAngles);
}
else
{
transform.rotation = Quaternion.Euler(trackRotation + staticRotation);
}
}
void OnCollisionEnter2D(Collision2D col)
{
Debug.Log("HIT");
Tilt parentScript = this.transform.parent.GetComponent <Tilt>();
if (col.gameObject.CompareTag("Rat"))
{
col.gameObject.transform.GetChild(0).gameObject.SetActive(true);
col.gameObject.transform.GetChild(0).GetComponent <AudioSource>().Play();
Destroy(col.gameObject, 0.15f);
if (gameObject.name == "LeftRectangle")
{
parentScript.toppleRightByRat(47000);
}
if (gameObject.name == "RightRectangle")
{
parentScript.toppleLeftByRat(47000);
}
}
}
public XmlNode ToXml(XmlNode parent)
{
XmlNode result = parent.OwnerDocument.CreateNode(XmlNodeType.Element, "Orientation", string.Empty);
// child nodes
XmlNode nodHeading = result.OwnerDocument.CreateNode(XmlNodeType.Element, "heading", string.Empty);
nodHeading.InnerText = Heading.ToString();
result.AppendChild(nodHeading);
XmlNode nodTilt = result.OwnerDocument.CreateNode(XmlNodeType.Element, "tilt", string.Empty);
nodTilt.InnerText = Tilt.ToString();
result.AppendChild(nodTilt);
XmlNode nodRoll = result.OwnerDocument.CreateNode(XmlNodeType.Element, "roll", string.Empty);
nodRoll.InnerText = Roll.ToString();
result.AppendChild(nodRoll);
return(result);
}
public static Universe ProcessData(JSONNode data)
{
Universe processedData = new Universe();
JSONNode base_stationsD = data ["base_stations"];
processedData.id = ChaperoneCalibrator.SplitQuote(data["id"]);
if (data ["lastChaperoneCommit"] != null)
{
processedData.lastChaperoneCommit = ChaperoneCalibrator.SplitQuote(data ["lastChaperoneCommit"]);
}
JSONNode tiltD = data ["tilt"];
processedData.tilt = Tilt.ProcessData(tiltD);
foreach (JSONNode baseS in base_stationsD.Children)
{
processedData.baseStationSerialNumberList.Add(baseS["base_serial_number"]);
}
return(processedData);
}
public byte[] CameraTilt(uint deviceAddress,Tilt action, uint speed)
{
if(speed<TiltSpeedMin)
speed = TiltSpeedMin;
if(speed<TiltSpeedMax)
speed = TiltSpeedMax;
return Message.GetMessage(deviceAddress,0x00,(byte)action,0x00,(byte)speed);
}
public byte[] CameraPanTilt(uint deviceAddress, Pan panAction, uint panSpeed, Tilt tiltAction, uint tiltSpeed)
{
byte[] m_bytes = new byte[8];
byte[] m_tiltMessage = CameraTilt(deviceAddress, tiltAction, tiltSpeed);
byte[] m_panMessage = CameraPan(deviceAddress, panAction, panSpeed);
//m_tiltMessage.CopyTo(m_bytes,0);
//m_panMessage.CopyTo(m_bytes,9);
/*m_bytes[0] = m_tiltMessage[0];
* m_bytes[1] = m_tiltMessage[1];
* m_bytes[2] = m_tiltMessage[2];
* m_bytes[3] = (byte)(m_tiltMessage[3]+m_panMessage[3]);
* m_bytes[4] = (byte)(+m_panMessage[4]);
* m_bytes[5] = (byte)(+m_panMessage[5]);
* m_bytes[6] = m_tiltMessage[6];
* m_bytes[7] = m_tiltMessage[7];*/
m_bytes = Message.GetMessage(deviceAddress, 0x00, (byte)(m_tiltMessage[3] + m_panMessage[3]),
m_panMessage[4], m_tiltMessage[5]);
return(m_bytes);
}
public byte[] CameraPanTilt(uint deviceAddress,Pan panAction, uint panSpeed, Tilt tiltAction, uint tiltSpeed)
{
byte[] m_bytes = new byte[8];
byte[] m_tiltMessage = CameraTilt(deviceAddress,tiltAction,tiltSpeed);
byte[] m_panMessage = CameraPan(deviceAddress,panAction,panSpeed);
//m_tiltMessage.CopyTo(m_bytes,0);
//m_panMessage.CopyTo(m_bytes,9);
/*m_bytes[0] = m_tiltMessage[0];
m_bytes[1] = m_tiltMessage[1];
m_bytes[2] = m_tiltMessage[2];
m_bytes[3] = (byte)(m_tiltMessage[3]+m_panMessage[3]);
m_bytes[4] = (byte)(+m_panMessage[4]);
m_bytes[5] = (byte)(+m_panMessage[5]);
m_bytes[6] = m_tiltMessage[6];
m_bytes[7] = m_tiltMessage[7];*/
m_bytes = Message.GetMessage(deviceAddress,0x00,(byte)(m_tiltMessage[3]+m_panMessage[3]),
m_panMessage[4],m_tiltMessage[5]);
return m_bytes;
}
public byte[] CameraPanTilt(uint deviceAddress,Pan panAction, uint panSpeed, Tilt tiltAction, uint tiltSpeed)
{
byte[] mTiltMessage = CameraTilt(deviceAddress,tiltAction,tiltSpeed);
byte[] mPanMessage = CameraPan(deviceAddress,panAction,panSpeed);
byte[] mBytes = Message.GetMessage(deviceAddress,0x00,(byte)(mTiltMessage[3]+mPanMessage[3]),
mPanMessage[4],mTiltMessage[5]);
return mBytes;
}
public byte[] CameraPanTilt(uint deviceAddress, Pan panAction, uint panSpeed, Tilt tiltAction, uint tiltSpeed)
{
byte[] m_bytes = new byte[8];
byte[] m_tiltMessage = CameraTilt(deviceAddress, tiltAction, tiltSpeed);
byte[] m_panMessage = CameraPan(deviceAddress, panAction, panSpeed);
m_bytes = Message.GetMessage(deviceAddress, 0x00, (byte)(m_tiltMessage[3] + m_panMessage[3]),
m_panMessage[4], m_tiltMessage[5]);
return(m_bytes);
}
