public RobotData SaveRobot(List <RobotPartRuntimeObject> robotParts) { RobotData CurrentRobot; CurrentRobot = new RobotData(); if (robotParts != null) { CurrentRobot.robotDataEntries = new List <RobotDataEntry>(); foreach (RobotPartRuntimeObject robotPartRuntimeObject in robotParts) { List <float> floatPartSettings = new List <float>(); List <bool> boolPartSettings = new List <bool>(); List <string> stringPartSettings = new List <string>(); if (robotPartRuntimeObject.robotPart.robotPartType == RobotPartType.WheelPart) { boolPartSettings.Add(robotPartRuntimeObject.robotPartGameObject.GetComponent <SimpleWheelController>().GetActivateMotor()); boolPartSettings.Add(robotPartRuntimeObject.robotPartGameObject.GetComponent <SimpleWheelController>().GetActivateSteering()); boolPartSettings.Add(robotPartRuntimeObject.robotPartGameObject.GetComponent <SimpleWheelController>().GetReverseSpinDirection()); } CurrentRobot.robotDataEntries.Add(new RobotDataEntry(robotPartRuntimeObject.parentIndex, robotPartRuntimeObject.robotPart.robotPartIdentifier, robotPartRuntimeObject.robotPartGameObject.transform.localPosition, robotPartRuntimeObject.robotPartGameObject.transform.localRotation, new RobotDataEntrySettings(floatPartSettings, boolPartSettings, stringPartSettings))); } } else { CurrentRobot = null; } return(CurrentRobot); }
/// <summary> /// Method the updates the enemy dictionary based on new scan data for a scanned robot. /// </summary> /// <param name="scannedRobotEvent">The scanned robot event containing data about the scanned robot.</param> private void UpdateEnemyDictionary(ScannedRobotEvent scannedRobotEvent) { var name = scannedRobotEvent.Name; // Check if data entry exists for the scanned robot if (enemyDictionary.ContainsKey(name)) { // Data entry exists => Update the current entry with new scanned data RobotData scannedRobot = enemyDictionary[name]; scannedRobot.Update(scannedRobotEvent, this); } else { // No data entry exists => Create a new data entry for the scanned robot RobotData scannedRobot = new RobotData(scannedRobotEvent, this); // Put the new data entry into the enemy dictionary enemyDictionary.Add(name, scannedRobot); } // Change the access order for the robot name, so the name is moved to, or added as the last entry if (accessedEnemyList.Contains(name)) { accessedEnemyList.Remove(name); } accessedEnemyList.Add(name); }
public void SaveJson() { //Name = "robot1"; Robot = GameObject.Find("Robot"); RobotData robot = new RobotData(); robot.RobotName = Name; robot.version = "1"; robot.CraftDate = DateTime.Now; Transform objList = Robot.GetComponentInChildren <Transform> (); robot.Objs = new GOData[500]; int i = 0; foreach (Transform child in objList) { Data script = child.gameObject.GetComponent <Data>(); robot.Objs[i].name = script.Name; robot.Objs[i].LocalPosition = RoundVector3(child.localPosition); robot.Objs[i].rotation = RoundQuaternion(child.rotation); i++; } string jsonstr = JsonUtility.ToJson(robot); savePlayerData(jsonstr); StartCoroutine("ShotPNG"); }
public void TestRobotData() { RobotData rd = new RobotData(); rd = RobotData.LoadFromFile(@"/Users/ritcma2020/Desktop/test.xml"); RobotData.CreateRobot(rd, Vector3.up * 6, Vector3.zero); }
/// <summary> /// This is the method that actually does the work. /// </summary> /// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param> protected override void SolveInstance(IGH_DataAccess DA) { // Get inputs. string inputRobotName = ""; Mesh inputEndeffectorMesh = new Mesh(); int inputRobotID = 0; Plane inputPlane = this.defaultPlane; if (!DA.GetData(0, ref inputRobotName)) { RobotOptionList(); } DA.GetData(1, ref inputEndeffectorMesh); DA.GetData(2, ref inputRobotID); DA.GetData(3, ref inputPlane); ////////////////////////////////////////////////////// // Process data. inputEndeffectorMesh.Weld(Math.PI); EndeffectorData endEffector = new EndeffectorData(MeshUtilities.EncodeMesh(inputEndeffectorMesh)); RobotData robot = new RobotData(inputRobotID, inputRobotName, endEffector, EncodeUtilities.EncodePlane(inputPlane)); UniversalDebug("Robot Object Created."); ////////////////////////////////////////////////////// // Output. DA.SetData(0, robot); #if DEBUG DA.SetData(1, this.debugMessages[this.debugMessages.Count - 1]); #endif }
/// <summary> /// Method that updates the direction of the radar based on new scan data for a scanned robot. /// </summary> /// <param name="scannedRobotEvent">The scanned robot event containing data about the scanned robot.</param> private void UpdateScanDirection(ScannedRobotEvent scannedRobotEvent) { // Gets the name of the scanned robot var scannedRobotName = scannedRobotEvent.Name; // Change the scanning direction if and only if we have no record for the oldest scanned // robot or the scanned robot IS the oldest scanned robot (based on the name) AND the enemy // dictionary contains scanned data entries for ALL robots (the size of the enemy dictionary is equal to // the number of opponent robots found by calling the getOthers() method). if ((oldestScanned == null || scannedRobotName.Equals(oldestScanned.name)) && accessedEnemyList.Count == Others) { // Get the oldest scanned robot data from our LinkedHashMap, where the first value // contains the oldest accessed entry, which is the robot we need to get. string oldestScannedName = accessedEnemyList[0]; RobotData oldestScannedRobot = enemyDictionary[oldestScannedName]; // Get the recent scanned position (x,y) of the oldest scanned robot double x = oldestScannedRobot.scannedX; double y = oldestScannedRobot.scannedY; // Get the heading of our robot double ourHeading = RadarHeadingRadians; // Calculate the bearing to the oldest scanned robot. // The bearing is the delta angle between the heading of our robot and the other robot, // which can be a positive or negative angle. double bearing = BearingTo(ourHeading, x, y); // Update the scan direction based on the bearing. // If the bearing is positive, the radar will be moved to the right. // If the bearing is negative, the radar will be moved to the left. scanDir = bearing; } }
public RobotData AcmeSeek(RobotData data, Func <int> getDistence) { // Get distance from the sensor. // Distance is wrapped to "IoMonad" and passed as a parameter // This way Seek is a pure function (Haskell way pure as IO is "outsourced") var newDistance = getDistence(); // Non pure: var newDistance = new Random().Next(0, 100); Trace.WriteLine($"ACME seek: {newDistance}"); var newSpeed = newDistance > 10 ? 100 : 0; var newIsActive = newDistance != 0 ? true : false; // TODO: Evade etc. return(new RobotData { Speed = newSpeed, Direction = data.Direction, CurrentLocation = data.CurrentLocation, DistanceToObstacle = newDistance, IsActive = newIsActive }); }
public static void CreateRobot(RobotData rd, Vector3 position, Vector3 rotation) { isLoading = true; foreach (Block block in Block.magicListOfAllBlocks) { if (block.attached == true && block.GetType() != typeof(Core)) { MonoBehaviour.Destroy(block.gameObject); } } Core.core.transform.position = position; Core.core.transform.rotation = Quaternion.Euler(rotation); Core.core.GetComponent <Rigidbody> ().velocity = Vector3.zero; Core.core.GetComponent <Rigidbody> ().angularVelocity = Vector3.zero; foreach (BlockData blockData in rd.blocks) { if (blockData.type != "Core") { GameObject blockObject = MonoBehaviour.Instantiate((GameObject)Resources.Load(blockData.type)); blockObject.transform.parent = Core.core.transform; blockObject.transform.localPosition = new Vector3(Mathf.Round(blockData.position.x), Mathf.Round(blockData.position.y), Mathf.Round(blockData.position.z)); blockObject.layer = 8; blockObject.GetComponent <BoxCollider> ().enabled = true; Block block = blockObject.GetComponent <Block> (); block.desiredRotation = blockData.rotation; //block.attached = true; block.Attach(new Vector3(Mathf.Round(blockData.position.x), Mathf.Round(blockData.position.y), Mathf.Round(blockData.position.z))); foreach (State state in blockData.states) { if (KeyState.isKeyState(state)) { KeyState ks = block.getState(state.stateName) as KeyState; KeyState dks = KeyState.getKeyState(state); ks.inputKey = dks.inputKey; ks.isActive = dks.isActive; if (dks.isActive) { ks.stateActivated.Invoke(); } ks.isToggleMode = dks.isToggleMode; } else if (!KeyState.isKeyState(state)) { State s = block.getState(state.stateName); s.isActive = state.isActive; if (state.isActive) { s.stateActivated.Invoke(); } } } } } //isLoading = false; }
public static void Save(string filepath, RobotData rd) { using (FileStream fs = new FileStream(filepath, FileMode.Create)) { rd.blocks = BlockData.PrepareBlockData(); XmlSerializer xml = new XmlSerializer(typeof(RobotData)); xml.Serialize(fs, rd); } }
public void saveRobot(RobotData r) { BinaryFormatter bf = new BinaryFormatter(); FileStream file = File.Create(savePath + r.botName + savExt); bf.Serialize(file, r); file.Close(); }
public static void Walk(RobotData thisRobot) { //robot hoda prema selectionu, prvo odredi smjer kretanja i dodaj speed float movDirection = thisRobot.selection.transform.position.x - thisRobot.myTransform.position.x; movDirection = movDirection / Mathf.Abs(movDirection); thisRobot.myRigidbody.AddForce(new Vector2(movDirection, 0) * thisRobot.speed); thisRobot.myAnimator.SetBool("Walk", true); }
private void load_nearby_area_msg(Robot robot, List <Robot> robots) { int areaId = robot.m_mapComponent.m_areaId; int[,] offset = new int[, ] { { -1, -1 }, { 0, -1 }, { 1, -1 }, { -1, 0 }, { 1, 0 }, { -1, 1 }, { 0, 1 }, { 1, 1 } }; int y = areaId / (int)m_areaAcount; int x = areaId % (int)m_areaAcount; //发送robot周围区域的所有robots的位置信息 NetworkMsg robotDataMsg = new NetworkMsg(); robotDataMsg.MsgType = Type.RobotsData; for (int i = 0; i < 8; i++) { int nearbyX = x + offset[i, 0]; int nearbyY = y + offset[i, 1]; if (nearbyX < 0 || nearbyX >= m_areaAcount || nearbyY < 0 || nearbyY >= m_areaAcount) { continue; } int nearbyAreaId = nearbyX + (int)m_areaAcount * nearbyY; Area nearbyArea = m_areasMap[nearbyAreaId]; List <int> nearbyRobotsList = nearbyArea.get_robotsIdList(); for (int k = 0; k < nearbyRobotsList.Count; k++) { int nearbyRobotId = nearbyRobotsList[k]; RobotData nearbyRobotData = new RobotData(); nearbyRobotData.ClientInfo = new ClientInfo(); nearbyRobotData.Position = new Position(); nearbyRobotData.ClientInfo.RobotSocketId = nearbyRobotId; nearbyRobotData.Position = robots[nearbyRobotId].m_mapComponent.m_pos; robotDataMsg.RobotData.Add(nearbyRobotData); } } //发送robot自己的位置信息 RobotData robotData = new RobotData(); robotData.ClientInfo = new ClientInfo(); robotData.Position = new Position(); robotData.ClientInfo.RobotSocketId = robot.m_socketId; robotData.Position = robot.m_mapComponent.m_pos; robotDataMsg.RobotData.Add(robotData); robot.m_clientSocket.dump_send_queue(robotDataMsg); }
private void SavePho2butt_Click(object sender, EventArgs e) { if (camera3.IsCameraOpen()) { camera3.StopCamera(); //EnbToolBtn(true); McamStatusLbl.Text = "Idle..."; McamStatusLbl.BackColor = Color.Orange; } for (int c = 0; c < 3; c++) { if (c == 1) { camera3.SetExposure(Para.RobotExposeTime + Convert.ToInt32((Convert.ToDouble(Para.RobotExposeTime) * 0.5))); } if (c == 2) { camera3.SetExposure(Para.RobotExposeTime + Convert.ToInt32((Convert.ToDouble(Para.RobotExposeTime) * 1))); } bool GrabPass = false; for (int j = 0; j < 3; j++) { if (camera3.Grab()) { GrabPass = true; break; } Application.DoEvents(); } if (!GrabPass) { return; } RobotData RDate = hWndCtrl3.RobotInspect(camera3.myImage, RobotClassPath + "\\Mod2"); if (RDate.Found) { HTuple hv_ReTuple = new HTuple(); HOperatorSet.ReadTuple(Para.RobotCurrentClass + "\\Mod2" + "\\BiaoDing2.tup", out hv_ReTuple); HTuple xx, yy; HOperatorSet.AffineTransPoint2d(hv_ReTuple, RDate.CenterX, RDate.CenterY, out xx, out yy); hWndCtrl3.RobotMod[1].CenterX = xx; hWndCtrl3.RobotMod[1].CenterY = yy; hWndCtrl3.RobotMod[1].CenterAngle = RDate.CenterAngle; hWndCtrl3.Save(mchSettingsFilePath); MessageBox.Show("Photo2 Pos Save OK"); return; } } MessageBox.Show("Photo2 Pos Save Error"); }
void Start() { spaces = new GameObject[size_x, size_y]; string parentTag = this.tag; // Sets up multidimensional array of grid tiles and sets their world position. for (int i = 0; i < size_y; i++) { for (int j = 0; j < size_x; j++) { int floor_rand = Random.Range(0, 150); if (floor_rand <= 120 || i == 0 || i == 1) { spaces[j, i] = Instantiate(floor_prefab, new Vector3(j, 0, i), Quaternion.identity); } else if (floor_rand > 120 && floor_rand <= 130) { spaces[j, i] = Instantiate(spin_floor_prefab, new Vector3(j, 0, i), Quaternion.identity); } else if (floor_rand > 130 && floor_rand <= 140) { spaces[j, i] = Instantiate(fall_floor_prefab, new Vector3(j, 0, i), Quaternion.identity); } else if (floor_rand > 140) { spaces[j, i] = Instantiate(teleport_floor_prefab, new Vector3(j, 0, i), Quaternion.identity); } spaces[j, i].transform.parent = this.transform; spaces[j, i].name = "Space " + i.ToString() + "," + j.ToString(); spaces[j, i].gameObject.tag = parentTag; Rigidbody rb = spaces[j, i].gameObject.AddComponent <Rigidbody>(); rb.useGravity = false; rb.isKinematic = true; } // gameObject.tag = "Spaces"; } // Spawns robots in the centre of the first row of grid tiles. robots = new GameObject[num_robots]; for (int i = 0; i < num_robots; i++) { int spawn_pos = ((size_x / 2) - (num_robots / 2)) + i; robots[i] = Instantiate(robot_prefab, new Vector3(spaces[spawn_pos, 0].transform.position.x, 0.5f, spaces[spawn_pos, 0].transform.position.z), Quaternion.identity); robots[i].name = "Player " + (i + 1).ToString(); robots[i].transform.parent = spaces[spawn_pos, 0].transform; RobotData data_scr = robots[i].GetComponent <RobotData>(); data_scr.SetPlayerNum(i); RobotMovement move_scr = robots[i].GetComponent <RobotMovement>(); move_scr.x_pos = spawn_pos; } rob_mov = robots[0].GetComponent <RobotMovement>(); rob_mov2 = robots[1].GetComponent <RobotMovement>(); }
public static void Box_Store(RobotData thisRobot) { //robot sprema selectirani box u container: //uništi box Object.Destroy(thisRobot.myTransform.Find("positionBox").GetChild(0).gameObject); //stopiraj robota i postavi mu parametre thisRobot.myRigidbody.velocity = Vector2.zero; thisRobot.myAnimator.SetBool("Walk", false); thisRobot.SetHasBox(false); thisRobot.selection = null; }
public List <RobotPartRuntimeObject> LoadFromScriptableObject(RobotDataSO robotDataSO, GameObject robotBodyGameObject) { List <RobotPartRuntimeObject> robotParts = new List <RobotPartRuntimeObject>(); RobotData robotData = robotDataSO.GetRobotData(); if (robotData != null) { robotParts = LoadRobot(robotData, robotBodyGameObject); } return(robotParts); }
public virtual RobotData getRobotData(TimePoint timePoint) { int i = Arrays.binarySearch(timePoints, timePoint); if (i < 0) { return(RobotData.createEmptyData(name)); } else { return(createDataUpToTimePoint(i)); } }
public virtual Prediction executeRobot(RobotData robotData, Robot robot) { prepare(robotData, robot); robotInstructionLimit = robot.Length * instructionLimitMultiplier; try { return(executeRobotMain()); } catch (System.Exception ex) when(ex is NotEnoughDataException || ex is TooManyInstructionsExecuted || ex is ArithmeticException) { return(Prediction.OUT); } }
private void prepare(RobotData robotData, Robot robot) { this.robot = robot; this.data = robotData; dataColumns = data.Columns; finished = false; instructionList = null; terminateInstructionList = false; changeInstructionPointer = 0; totalInstructionExecuted = 0; dataMaximumOffset = robot.MaximumDataOffset; ignoreColumns = robot.IgnoreColumns; zeroOutRegisters(); }
private void Setup() { if (!Data) { return; } InstanceData = Instantiate(Data); ID = InstanceData.Unique_ID; strength = InstanceData.Strength; upgrade = InstanceData.Upgrade; for (int i = 0; i < Data.Ability_Array.Length; i++) { Abilities [i % 3, i / 3] = InstanceData.Ability_Array [i]; } }
public void setup() { robot = GameObject.Find("Robot") as GameObject; if (!robot) { Debug.LogError("Couldn't find robot in setup for RobotEditor"); gameObject.SetActive(false); return; } r = robot.GetComponent <Robot> (); rd = r.rd; populatePages(); }
public static Transform GetSelectionContainer(RobotData thisRobot) { //hardcode-ano traženje ispravnog containera za selectani box - moglo bi ići napredno traženje ali nije bitno za ove dvije vrste box-ova if (thisRobot.myTransform.Find("positionBox").GetChild(0).name == "Box_Red") { return(GameObject.Find("Container_Red").transform); } else if (thisRobot.myTransform.Find("positionBox").GetChild(0).name == "Box_Blue") { return(GameObject.Find("Container_Blue").transform); } //ako je robot primio neispravni objekt Debug.Log("There is no container for selected object"); return(null); }
public RobotData AcmeDrive(RobotData data) { var newlocation = data.CurrentLocation + data.Speed * data.Direction; Trace.WriteLine($"ACME drive: {newlocation}"); return(new RobotData { Speed = data.Speed, Direction = data.Direction, CurrentLocation = newlocation, DistanceToObstacle = data.DistanceToObstacle, IsActive = data.IsActive }); }
//------------------------------------------------ //r save //------------------------------------------------ public RobotData newRobot(string newRobot) { if (!File.Exists(savePath + newRobot + savExt)) { Debug.Log("Creating new Robot: " + newRobot); RobotData r = new RobotData(); r.botName = newRobot; saveRobot(r); return(r); } else { Debug.Log("A robot with this name already exists"); return(null); } }
public static void Box_Pickup(RobotData thisRobot) { //robot uzima selectirani box na sebe: //isključi od sada nepotrebne kompnente boxa i ispravno postavi box gameobjekt Object.Destroy(thisRobot.selection.GetComponent <BoxCollider2D>()); Object.Destroy(thisRobot.selection.GetComponent <Rigidbody2D>()); Transform positionBox = thisRobot.myTransform.Find("positionBox"); thisRobot.selection.SetParent(positionBox); thisRobot.selection.position = new Vector3(positionBox.position.x, positionBox.position.y, -1.1f); //stopiraj robota i postavi mu parametre thisRobot.myRigidbody.velocity = Vector2.zero; thisRobot.myAnimator.SetBool("Walk", false); thisRobot.SetHasBox(true); thisRobot.selection = null; }
public void SaveFile(string path, List <RobotPartRuntimeObject> robotParts) { RobotData robotData = SaveRobot(robotParts); if (robotData != null) { if (Application.platform == RuntimePlatform.WindowsEditor || Application.platform == RuntimePlatform.WindowsPlayer) { robotData.SaveRobotDataBinaryToFile(path); } else { robotData.SaveRobotDataJsonToPlayerPrefs(path); UpdatePlayerPrefsRobotList(path); } //robotData.SaveRobotDataJsonToPlayerPrefs("PlayerPrefs.robot"); } }
HTuple BR = new HTuple(); //通道2的图像Row坐标 private bool BiaoDingCamera(HTuple Colunm, HTuple Row, HTuple R, int xi, string strpath) { for (int c = 0; c < 3; c++) { if (c == 0) { camera3.SetExposure(Para.RobotExposeTime); } if (c == 1) { camera3.SetExposure(Para.RobotExposeTime + Convert.ToInt32((Convert.ToDouble(Para.RobotExposeTime) * 0.2))); } if (c == 2) { camera3.SetExposure(Para.RobotExposeTime - Convert.ToInt32((Convert.ToDouble(Para.RobotExposeTime) * 0.2))); } bool GrabPass = false; for (int j = 0; j < 3; j++) { if (camera3.Grab()) { GrabPass = true; break; } Application.DoEvents(); } if (!GrabPass) { return(false); } RobotData RDate = hWndCtrl3.RobotInspect(camera3.myImage, strpath); if (RDate.Found) { Colunm[xi] = RDate.CenterX; Row[xi] = RDate.CenterY; R[xi] = RDate.CenterAngle; return(true); } } Colunm = 0; Row = 0; return(false); }
/// <summary> /// This method is called by the game when another robot dies. /// </summary> /// <param name="robotDeathEvent">The robot death event containing data about the robot that died.</param> public override void OnRobotDeath(RobotDeathEvent robotDeathEvent) { // Gets the name of the robot that died var deadRobotName = robotDeathEvent.Name; // Remove the robot data for the robot that died from the enemy dictionary and access list enemyDictionary.Remove(deadRobotName); accessedEnemyList.Remove(deadRobotName); // Remove the data entry for the oldest scanned robot, if we have such an entry if (oldestScanned != null && oldestScanned.name.Equals(deadRobotName)) { oldestScanned = null; } if (target != null && target.name.Equals(deadRobotName)) { target = null; } }
private RobotData createDataUpToTimePoint(int i) { IList <double []> list = new List <double []>(); foreach (double[] original in values) { double[] copy = copyReverseArray(original, i); list.Add(copy); } try { double?futureChange = calculateFutureChange(timePoints[i]); return(RobotData.createData(list, name, futureChange.Value)); } catch (NoDataForTimePointException) { return(RobotData.createEmptyData(name)); } }
/// <summary> /// Updates which enemy robot from the enemy dictionary that should be our current target. /// </summary> private void UpdateTarget() { // Set target to null, meaning that we have no target robot yet target = null; // Create a list over possible target robots that is a copy of robot data from the enemy dictionary List <RobotData> targets = new List <RobotData>(enemyDictionary.Values); // Run thru all the possible target robots and remove those that are outside the attack // range for this border sentry robot as our robot cannot do harm to robots outside its // range. for (int i = targets.Count - 1; i >= 0; i--) // avoids error "Collection was modified" { RobotData robot = targets[i]; if (IsOutsideAttackRange(robot.targetX, robot.targetY)) { targets.Remove(robot); } } // Set the target robot to be the one among all possible target robots that is closest to // our robot. double minDist = Double.PositiveInfinity; foreach (RobotData robot in targets) { double dist = DistanceTo(robot.targetX, robot.targetY); if (dist < minDist) { minDist = dist; target = robot; } } // If we still haven't got a target robot, then take the first one from our list of target // robots if the list is not empty. if (target == null && targets.Count > 0) { target = targets[0]; } }
/// <summary> /// Updates which enemy robot from the enemy dictionary that should be our current target. /// </summary> private void UpdateTarget() { // Set target to null, meaning that we have no target robot yet target = null; // Create a list over possible target robots that is a copy of robot data from the enemy dictionary List<RobotData> targets = new List<RobotData>(enemyDictionary.Values); // Run thru all the possible target robots and remove those that are outside the attack // range for this border sentry robot as our robot cannot do harm to robots outside its // range. for (int i = targets.Count - 1; i >= 0; i--) // avoids error "Collection was modified" { RobotData robot = targets[i]; if (IsOutsideAttackRange(robot.targetX, robot.targetY)) { targets.Remove(robot); } } // Set the target robot to be the one among all possible target robots that is closest to // our robot. double minDist = Double.PositiveInfinity; foreach (RobotData robot in targets) { double dist = DistanceTo(robot.targetX, robot.targetY); if (dist < minDist) { minDist = dist; target = robot; } } // If we still haven't got a target robot, then take the first one from our list of target // robots if the list is not empty. if (target == null && targets.Count > 0) { target = targets[0]; } }
public FrameData(string text) { string[] data = text.Split('|'); string[] robotText = data[0].Split('*'); string[] bulletText = data[1].Split ('*'); string[] hitText = data[2].Split('*'); string[] arsenalText = data[3].Split('*'); robotData = new RobotData[robotText.Length]; for(int i = 0; i<robotText.Length; i++) { robotData[i] = new RobotData(robotText[i]); } if(bulletText[0] != "") { bulletData = new BulletData[bulletText.Length]; for(int i = 0; i<bulletText.Length; i++) { bulletData[i] = new BulletData(bulletText[i]); } } else { bulletData = null; } if(hitText[0] != "") { hitData = new HitData[hitText.Length]; for(int i = 0; i<hitText.Length; i++) { hitData[i] = new HitData(hitText[i]); } } else { hitData = null; } if(arsenalText[0] != "") { arsenalRespawnTime = new int[arsenalText.Length]; for(int i = 0; i<arsenalText.Length; i++) { arsenalRespawnTime[i] = Convert.ToInt32(arsenalText[i]); } } else { arsenalRespawnTime = null; } }
RobotData CreateRobotDataFromPlayerPrefs() { RobotData robotData = new RobotData(); return robotData; }