public void CreateAssignment(Guid groupId, long unitId, SerializedTaskLaunchInfo taskLaunchInfo, bool hasTarget = false, int targetPlayerIndex = -1, long targetId = 0)
        {
            IMatchPlayerView    targetPlayerView  = null;
            IMatchUnitAssetView targetUnitOrAsset = null;

            if (hasTarget)
            {
                targetPlayerView  = m_players[targetPlayerIndex];
                targetUnitOrAsset = targetPlayerView.GetUnitOrAsset(targetId);
                if (targetUnitOrAsset == null || !targetUnitOrAsset.IsAlive)
                {
                    hasTarget         = false;
                    targetId          = 0;
                    targetPlayerIndex = -1;
                }
            }

            IMatchUnitAssetView unit = m_players[m_playerIndex].GetUnitOrAsset(unitId);

            Assignment assignment = new Assignment
            {
                GroupId           = groupId,
                UnitId            = unitId,
                HasUnit           = true,
                TaskLaunchInfo    = taskLaunchInfo,
                TargetPlayerIndex = targetPlayerIndex,
                TargetId          = targetId,
                HasTarget         = hasTarget
            };

            if (unit.Assignment != null)
            {
                RemoveUnitFromAssignment(unit);
            }

            unit.Assignment = assignment;
            if (hasTarget)
            {
                if (targetUnitOrAsset.TargetForAssignments == null)
                {
                    targetUnitOrAsset.TargetForAssignments = new List <Assignment>();
                }
                targetUnitOrAsset.TargetForAssignments.Add(assignment);
            }

            AssignmentGroup group;

            if (!m_groupIdToAssignments.TryGetValue(groupId, out group))
            {
                group = new AssignmentGroup {
                    GroupId = groupId, Assignments = new List <Assignment>()
                };

                m_groupIdToAssignments.Add(groupId, group);
            }

            group.Assignments.Add(assignment);
        }
        private void RemoveAssignment(Assignment assignment, Action <VoxelData> dieCallback)
        {
            if (assignment.HasUnit)
            {
                IMatchPlayerView    playerView  = m_players[m_playerIndex];
                IMatchUnitAssetView unitOrAsset = playerView.GetUnitOrAsset(assignment.UnitId);
                if (unitOrAsset != null)
                {
                    unitOrAsset.Assignment = null;
                }
            }

            assignment.HasUnit = false;
            assignment.UnitId  = 0;

            if (assignment.HasTarget)
            {
                IMatchPlayerView    targetPlayerView  = m_players[assignment.TargetPlayerIndex];
                IMatchUnitAssetView targetUnitOrAsset = targetPlayerView.GetUnitOrAsset(assignment.TargetId);
                if (targetUnitOrAsset != null && targetUnitOrAsset.TargetForAssignments != null)
                {
                    targetUnitOrAsset.TargetForAssignments.Remove(assignment);
                    if (targetUnitOrAsset.TargetForAssignments.Count == 0)
                    {
                        targetUnitOrAsset.TargetForAssignments = null;
                        //destroy preview here
                        if (VoxelData.IsPreview(targetUnitOrAsset.Data.Type))
                        {
                            targetUnitOrAsset.DataController.SetHealth(0);
                            if (dieCallback != null)
                            {
                                dieCallback(targetUnitOrAsset.Data);
                            }
                        }
                    }
                }

                assignment.HasTarget         = false;
                assignment.TargetId          = 0;
                assignment.TargetPlayerIndex = -1;
            }

            AssignmentGroup group;

            if (m_groupIdToAssignments.TryGetValue(assignment.GroupId, out group))
            {
                group.Assignments.Remove(assignment);
                if (group.Assignments.Count == 0)
                {
                    m_groupIdToAssignments.Remove(assignment.GroupId);
                }
            }
        }
示例#3
0
        protected override void OnEvaluating(ExpressionInfo expression, ITaskEngine taskEngine, Action <object> callback)
        {
            ExpressionInfo left  = expression.Children[0];
            ExpressionInfo right = expression.Children[1];

            taskEngine.GetExpression(left.Code).Evaluate(left, taskEngine, first =>
            {
                taskEngine.GetExpression(right.Code).Evaluate(right, taskEngine, second =>
                {
                    long unitId  = (long)first;
                    int playerId = (int)second;

                    IMatchPlayerView player  = taskEngine.MatchEngine.GetPlayerView(playerId);
                    IMatchUnitAssetView unit = player.GetUnitOrAsset(unitId);

                    OnEvaluating(expression, player, unit, taskEngine, callback);
                });
            });
        }