public void SetPath(Vector3[] paths, bool isRay = false) { List <Vector3> points = new List <Vector3>(); for (int i = 0; i < paths.Length; i++) { points.Add(paths[i].Clone()); } PathGroup group = new PathGroup(); group.gap = gap; group.pathNum = 8; group.lengthRadius = lengthRadius; group.hitRadiusMultiply = hitRadiusMultiply; group.hitRadiusMultiplyVertical = hitRadiusMultiplyVertical; group.buildLayer = layerMask_Build; group.points = points; group.GenerationSubPaths(); group.CheckBuild(); for (int i = 0; i < group.paths.Count; i++) { group.paths[i].s0 = group.paths[0].s; } War.scene.AddPathCache(onceCount, from, to, group); SetPathGroup(group); }
public void SetContents(List <IContent> contentsBefore, List <IContent> contentsAfter) { TrimPathContent trimPathContentBefore = null; for (var i = contentsBefore.Count - 1; i >= 0; i--) { var content = contentsBefore[i]; if (content is TrimPathContent trimPathContent && trimPathContent.Type == ShapeTrimPath.Type.Individually) { trimPathContentBefore = trimPathContent; } } if (trimPathContentBefore != null) { trimPathContentBefore.ValueChanged += OnValueChanged; } PathGroup currentPathGroup = null; for (var i = contentsAfter.Count - 1; i >= 0; i--) { var content = contentsAfter[i]; if (content is TrimPathContent trimPathContent && trimPathContent.Type == ShapeTrimPath.Type.Individually) { if (currentPathGroup != null) { _pathGroups.Add(currentPathGroup); } currentPathGroup = new PathGroup(trimPathContent); trimPathContent.ValueChanged += OnValueChanged; }
public void AddPathCache(int onceCount, Transform from, Transform to, PathGroup pathGroup) { Dictionary <Transform, Dictionary <Transform, PathGroup> > onceCountDict = null; if (!pathCache.TryGetValue(onceCount, out onceCountDict)) { onceCountDict = new Dictionary <Transform, Dictionary <Transform, PathGroup> >(); pathCache.Add(onceCount, onceCountDict); } Dictionary <Transform, PathGroup> fromDict = null; if (!onceCountDict.TryGetValue(from, out fromDict)) { fromDict = new Dictionary <Transform, PathGroup>(); onceCountDict.Add(from, fromDict); } if (fromDict.ContainsKey(to)) { fromDict[to] = pathGroup; } else { fromDict.Add(to, pathGroup); } }
public WaypointEventArgs(ReasonType t, PathGroup g, RobotPath s, WayPoint pt) { Reason = t; Group = g; Path = s; Point = pt; }
public void MoveTo(Transform from, Transform to) { this.from = from; this.to = to; PathGroup pathGroup = War.scene.GetPathCache(onceCount, from, to); if (pathGroup != null) { SetPathGroup(pathGroup); } else { Vector3[] paths = War.sceneData.pathData.GetPath(fromUnitCtl.unitData.uid, toUnitCtl.unitData.uid); SetPath(paths); // RaycastHit hitInfo; // if (Physics.Linecast(from.position, to.position, out hitInfo, layerMask_Obstacle.value)) // { // StartCoroutine(DelayMoveTo()); // } // else // { // Vector3[] paths = new Vector3[]{from.position, to.position}; // SetPath(paths); // } } }
public WaypointEventArgs(ReasonType t) { Reason = t; Group = null; Path = null; Point = null; }
public void Serialize(IByteBuffer byteBuffer, GetTrieNodesMessage message) { (int contentLength, int allPathsLength, int[] pathsLengths) = CalculateLengths(message); byteBuffer.EnsureWritable(Rlp.LengthOfSequence(contentLength), true); NettyRlpStream stream = new (byteBuffer); stream.StartSequence(contentLength); stream.Encode(message.RequestId); stream.Encode(message.RootHash); if (message.Paths == null || message.Paths.Length == 0) { stream.EncodeNullObject(); } else { stream.StartSequence(allPathsLength); for (int i = 0; i < message.Paths.Length; i++) { PathGroup group = message.Paths[i]; stream.StartSequence(pathsLengths[i]); for (int j = 0; j < group.Group.Length; j++) { stream.Encode(group.Group[j]); } } } stream.Encode(message.Bytes); }
private PathGroup DecodeGroup(RlpStream stream) { PathGroup group = new PathGroup(); group.Group = stream.DecodeArray(s => stream.DecodeByteArray()); return(group); }
PathNode buildPathNode(PathGroup group, int index) { Goal goal = group.getGoal(index); PathNode node = new PathNode(); node.init(goal); return(node); }
private void initPathGroup() { if (transform.position.x > 0) { pathGroup = PathManager.right; } else { pathGroup = PathManager.left; } }
protected void Start() { _mapPlatform = MapPlatformGameObject.GetComponent <MapPlatform>(); _pathGroupTeam1 = PathGroupTeam1.GetComponent <PathGroup>(); _pathGroupTeam2 = PathGroupTeam2.GetComponent <PathGroup>(); _currentShadowTiles2X2 = new List <GameObject>(); if (Debugger) { _myDebugger = Debugger.GetComponent <MyDebugger>(); } Instance = this; }
private PathGroup[] GetPathGroups(AccountsToRefreshRequest request) { PathGroup[] groups = new PathGroup[request.Paths.Length]; for (int i = 0; i < request.Paths.Length; i++) { AccountWithStorageStartingHash path = request.Paths[i]; groups[i] = new PathGroup() { Group = new[] { path.PathAndAccount.Path.Bytes, _emptyBytes } }; } return(groups); }
public void create(int[] pointsIndex, PathGroup group) { //groupName = group.name; nodes = new PathNode[pointsIndex.Length]; for (int i = 0; i < pointsIndex.Length; i++) { int index = pointsIndex[i]; nodes[i] = buildPathNode(group, index); } //connectNodes for (int i = 0; i < nodes.Length; i++) { int j = i + 1; if (j < nodes.Length) { nodes[i].next = nodes[j]; } } }
public void Roundtrip_OneAccountPath() { GetTrieNodesMessage msg = new() { RequestId = MessageConstants.Random.NextLong(), RootHash = TestItem.KeccakA, Paths = new PathGroup[] { new PathGroup() { Group = new [] { TestItem.RandomDataA } } }, Bytes = 10 }; GetTrieNodesMessageSerializer serializer = new(); SerializerTester.TestZero(serializer, msg); }
public static void init() { pathDefine = new int[][] { new int[] { 1, 2, 9, 10 }, new int[] { 12, 10, 9, 4, 11 }, new int[] { 1, 2, 9, 4, 11 }, new int[] { 12, 10, 9 }, new int[] { 1, 2, 9 }, new int[] { 12, 10, 9, 2, 3, 4, 5, 6, 7, 8 }, new int[] { 1, 2, 3, 4, 5, 6, 7, 8 }, }; left = new PathGroup(); left.constructPath(GameObject.Find("leftPath").transform, pathDefine); right = new PathGroup(); right.constructPath(GameObject.Find("rightPath").transform, pathDefine); }
public void SetPathGroup(PathGroup pathGroup) { if (isInitCache) { Destroy(gameObject); return; } int count = list.Count; group = pathGroup.Clone(count); for (int i = 0; i < count; i++) { list[i].SetPath(group.paths[i]); } group.Synchronous(0.5f, War.scene); Destroy(gameObject); }
private (int contentLength, int allPathsLength, int[] pathsLengths) CalculateLengths(GetTrieNodesMessage message) { int contentLength = Rlp.LengthOf(message.RequestId); contentLength += Rlp.LengthOf(message.RootHash); int allPathsLength = 0; int[] pathsLengths = new int[message.Paths.Length]; if (message.Paths == null || message.Paths.Length == 0) { allPathsLength = 1; } else { for (var i = 0; i < message.Paths.Length; i++) { PathGroup pathGroup = message.Paths[i]; int groupLength = 0; foreach (byte[] path in pathGroup.Group) { groupLength += Rlp.LengthOf(path); } pathsLengths[i] = groupLength; allPathsLength += Rlp.LengthOfSequence(groupLength); } } contentLength += Rlp.LengthOfSequence(allPathsLength); contentLength += Rlp.LengthOf(message.Bytes); return(contentLength, allPathsLength, pathsLengths); }
// Use this for initialization void Start() { _group = GetComponent<PathGroup> (); }
void ResetPathGroup(PathGroup pathGroup) { if (path) { pathContainer = path.GetComponent<PathContainer> (); } if (pathContainer && pathGroup == pathContainer.pathGroup) { //Debug.Log ("ResetPathGroup: "+pathHead); transform.position = pathHead.transform.position; } }
// Use this for initialization void Start() { _pathGroup = pathGroupObj.GetComponent<PathGroup> (); }
void ResetPathGroup(PathGroup pathGroup) { }
protected override void OnUpdate() { base.OnUpdate(); if (!sendArmData.sending) { return; } if (!War.isGameing) { return; } if (_forced == false && unitData.freezedSendArm) { return; } if (unitData.unitNum <= 0 || unitData.death) { Stop(); return; } armOnceWidth = legionData.soliderData.armOnceWidth; radius = legionData.soliderData.radius; gapV = legionData.soliderData.gapV; gapH = radius * 2; if (gapV < 0) { gapV = gapH; } if (armOnceWidth < 0) { armOnceWidth = 8; } onceCount = Mathf.FloorToInt(armOnceWidth / gapH); targetCount = sendArmData.targets.Count; for (int j = 0; j < targetCount; j++) { SendArmDataTarget targetData = sendArmData.targets[j]; int count = Mathf.Min(targetData.num, onceCount); count = Mathf.Min(count, unitData.unitNum); //Debug.Log ("j=" + j + " count=" + count + " targetData.num=" + targetData.num); if (count <= 0) { sendArmData.WillRemoveTarget(targetData); continue; } if (count > 8) { count = 8; } if (Time.time > targetData.nextTime) { PathGroup pathGroup = War.scene.GetPathCache(onceCount, transform, targetData.target.transform); isInitPathCache = pathGroup != null; List <UnitPath> unitPathList = new List <UnitPath>(); UnitPathGroup unitPathGroup = null; if (!isInitPathCache) { GameObject groupGO = War.factory.CreatePathGroup(); groupGO.transform.position = transform.position; unitPathGroup = groupGO.GetComponent <UnitPathGroup>(); } float moveSpeed = 1f; for (int i = 0; i < count; i++) { int pathIndex = (int)((i + 1) / 2) * (i % 2 == 0 ? 1 : -1); targetData.num += -1; sendArmData.sendNum += -1; unitData.AddUnitNum(-1); // GameObject soliderGO = War.factory.CreateSolider(unitData.legionId); GameObject soliderGO = War.soliderPool.Get(); UnitData soliderUnitData = legionData.soliderData.Clone(); soliderUnitData.id = targetData.idBegin++; soliderUnitData.from = unitData; soliderUnitData.to = targetData.target.unitData; unitData.soliderPropContainer.UnitApp(soliderUnitData); legionData.soliderPropContainer.UnitApp(soliderUnitData); legionData.soliderInitPropContainer.UnitApp(soliderUnitData, true); soliderGO.AddEComponent(soliderUnitData); soliderUnitData.Init(); if (targetData.forced) { soliderUnitData.moveSpeed = targetData.speed; } UnitAgent unitAgent = soliderGO.GetComponent <UnitAgent>(); unitAgent.Walk(); unitAgent.angel = HMath.angle(transform.position.z, transform.position.x, targetData.target.transform.position.z, targetData.target.transform.position.x); soliderGO.name = "War_Solider-" + soliderUnitData.id; UnitPath unitPath = soliderGO.GetComponent <UnitPath>(); unitPath.index = pathIndex; unitPath.maxSpeed = targetData.forced ? targetData.speed : soliderUnitData.moveSpeed; soliderGO.transform.position = transform.position; if (isInitPathCache) { unitPathList.Add(unitPath); } else { unitPathGroup.list.Add(unitPath); } moveSpeed = unitPath.maxSpeed; if (targetData.forced) { soliderUnitData.moveSpeed = moveSpeed; soliderUnitData.Props[PropId.InitMoveSpeed] = moveSpeed; } soliderUnitData.to.AddFromLegionUnit(soliderUnitData.legionId, 1); SoliderPoolItem soliderPoolItem = soliderGO.GetComponent <SoliderPoolItem>(); if (soliderPoolItem != null) { soliderPoolItem.Rest(); } } // Debug.Log(string.Format("<color=green>isInitPathCache={0}</color>", isInitPathCache)); if (isInitPathCache) { pathGroup = War.scene.GetPathCache(onceCount, transform, targetData.target.transform); int unitPathListCount = unitPathList.Count; pathGroup = pathGroup.Clone(unitPathListCount); for (int i = 0; i < unitPathListCount; i++) { unitPathList[i].SetPath(pathGroup.paths[i]); } } else { unitPathGroup.gap = gapH; unitPathGroup.pathNum = count; unitPathGroup.onceCount = onceCount; unitPathGroup.MoveTo(unitCtl, targetData.target); } if (float.IsNaN(moveSpeed) || moveSpeed <= 0) { moveSpeed = 1f; } targetData.nextTime = Time.time + (gapV + sendArmData.sendUnitSpeed) / moveSpeed; } } sendArmData.ExeRemoveTargets(); }