Alpha/TaskNode.cs at master · OneGitStep/Alpha · GitHub

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
usingSystem;
usingSystem.Collections.Generic;
usingSystem.Linq;
usingSystem.Text;
usingSystem.Threading.Tasks;
usingSharpDX;

namespaceAlpha
{
publicclassTaskNode
{
/// <summary>
/// The position of the task in world space.
/// </summary>
publicVector3WorldPosition{get;set;}
/// <summary>
/// Type of task we are performing. Different tasks have different underlying logic
/// </summary>
publicTaskNodeTypeType{get;set;}
/// <summary>
/// Bounds represents how close we must get to the node to complete it.
/// Some tasks require multiple actions within Bounds to be marked as complete.
/// </summary>
publicintBounds{get;set;}

/// <summary>
/// Counts the number of times the Task has been executed. Used for canceling invalid actions
/// </summary>
publicintAttemptCount{get;set;}


publicTaskNode(Vector3position,intbounds,TaskNodeTypetype=TaskNodeType.Movement)
{
WorldPosition=position;
Type=type;
Bounds=bounds;
}
}
}
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
usingSystem;
usingSystem.Collections.Generic;
usingSystem.Linq;
usingSystem.Text;
usingSystem.Threading.Tasks;
usingSharpDX;

namespaceAlpha
{
publicclassTaskNode
{
/// <summary>
/// The position of the task in world space.
/// </summary>
publicVector3WorldPosition{get;set;}
/// <summary>
/// Type of task we are performing. Different tasks have different underlying logic
/// </summary>
publicTaskNodeTypeType{get;set;}
/// <summary>
/// Bounds represents how close we must get to the node to complete it.
/// Some tasks require multiple actions within Bounds to be marked as complete.
/// </summary>
publicintBounds{get;set;}

/// <summary>
/// Counts the number of times the Task has been executed. Used for canceling invalid actions
/// </summary>
publicintAttemptCount{get;set;}


publicTaskNode(Vector3position,intbounds,TaskNodeTypetype=TaskNodeType.Movement)
{
WorldPosition=position;
Type=type;
Bounds=bounds;
}
}
}
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
usingSystem;
usingSystem.Collections.Generic;
usingSystem.Linq;
usingSystem.Text;
usingSystem.Threading.Tasks;
usingSharpDX;

namespaceAlpha
{
publicclassTaskNode
{
/// <summary>
/// The position of the task in world space.
/// </summary>
publicVector3WorldPosition{get;set;}
/// <summary>
/// Type of task we are performing. Different tasks have different underlying logic
/// </summary>
publicTaskNodeTypeType{get;set;}
/// <summary>
/// Bounds represents how close we must get to the node to complete it.
/// Some tasks require multiple actions within Bounds to be marked as complete.
/// </summary>
publicintBounds{get;set;}

/// <summary>
/// Counts the number of times the Task has been executed. Used for canceling invalid actions
/// </summary>
publicintAttemptCount{get;set;}


publicTaskNode(Vector3position,intbounds,TaskNodeTypetype=TaskNodeType.Movement)
{
WorldPosition=position;
Type=type;
Bounds=bounds;
}
}
}
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
usingSystem;
usingSystem.Collections.Generic;
usingSystem.Linq;
usingSystem.Text;
usingSystem.Threading.Tasks;
usingSharpDX;

namespaceAlpha
{
publicclassTaskNode
{
/// <summary>
/// The position of the task in world space.
/// </summary>
publicVector3WorldPosition{get;set;}
/// <summary>
/// Type of task we are performing. Different tasks have different underlying logic
/// </summary>
publicTaskNodeTypeType{get;set;}
/// <summary>
/// Bounds represents how close we must get to the node to complete it.
/// Some tasks require multiple actions within Bounds to be marked as complete.
/// </summary>
publicintBounds{get;set;}

/// <summary>
/// Counts the number of times the Task has been executed. Used for canceling invalid actions
/// </summary>
publicintAttemptCount{get;set;}


publicTaskNode(Vector3position,intbounds,TaskNodeTypetype=TaskNodeType.Movement)
{
WorldPosition=position;
Type=type;
Bounds=bounds;
}
}
}
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
usingSystem;
usingSystem.Collections.Generic;
usingSystem.Linq;
usingSystem.Text;
usingSystem.Threading.Tasks;
usingSharpDX;

namespaceAlpha
{
publicclassTaskNode
{
/// <summary>
/// The position of the task in world space.
/// </summary>
publicVector3WorldPosition{get;set;}
/// <summary>
/// Type of task we are performing. Different tasks have different underlying logic
/// </summary>
publicTaskNodeTypeType{get;set;}
/// <summary>
/// Bounds represents how close we must get to the node to complete it.
/// Some tasks require multiple actions within Bounds to be marked as complete.
/// </summary>
publicintBounds{get;set;}

/// <summary>
/// Counts the number of times the Task has been executed. Used for canceling invalid actions
/// </summary>
publicintAttemptCount{get;set;}


publicTaskNode(Vector3position,intbounds,TaskNodeTypetype=TaskNodeType.Movement)
{
WorldPosition=position;
Type=type;
Bounds=bounds;
}
}
}
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
usingSystem;
usingSystem.Collections.Generic;
usingSystem.Linq;
usingSystem.Text;
usingSystem.Threading.Tasks;
usingSharpDX;

namespaceAlpha
{
publicclassTaskNode
{
/// <summary>
/// The position of the task in world space.
/// </summary>
publicVector3WorldPosition{get;set;}
/// <summary>
/// Type of task we are performing. Different tasks have different underlying logic
/// </summary>
publicTaskNodeTypeType{get;set;}
/// <summary>
/// Bounds represents how close we must get to the node to complete it.
/// Some tasks require multiple actions within Bounds to be marked as complete.
/// </summary>
publicintBounds{get;set;}

/// <summary>
/// Counts the number of times the Task has been executed. Used for canceling invalid actions
/// </summary>
publicintAttemptCount{get;set;}


publicTaskNode(Vector3position,intbounds,TaskNodeTypetype=TaskNodeType.Movement)
{
WorldPosition=position;
Type=type;
Bounds=bounds;
}
}
}
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
usingSystem;
usingSystem.Collections.Generic;
usingSystem.Linq;
usingSystem.Text;
usingSystem.Threading.Tasks;
usingSharpDX;

namespaceAlpha
{
publicclassTaskNode
{
/// <summary>
/// The position of the task in world space.
/// </summary>
publicVector3WorldPosition{get;set;}
/// <summary>
/// Type of task we are performing. Different tasks have different underlying logic
/// </summary>
publicTaskNodeTypeType{get;set;}
/// <summary>
/// Bounds represents how close we must get to the node to complete it.
/// Some tasks require multiple actions within Bounds to be marked as complete.
/// </summary>
publicintBounds{get;set;}

/// <summary>
/// Counts the number of times the Task has been executed. Used for canceling invalid actions
/// </summary>
publicintAttemptCount{get;set;}


publicTaskNode(Vector3position,intbounds,TaskNodeTypetype=TaskNodeType.Movement)
{
WorldPosition=position;
Type=type;
Bounds=bounds;
}
}
}
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
usingSystem;
usingSystem.Collections.Generic;
usingSystem.Linq;
usingSystem.Text;
usingSystem.Threading.Tasks;
usingSharpDX;

namespaceAlpha
{
publicclassTaskNode
{
/// <summary>
/// The position of the task in world space.
/// </summary>
publicVector3WorldPosition{get;set;}
/// <summary>
/// Type of task we are performing. Different tasks have different underlying logic
/// </summary>
publicTaskNodeTypeType{get;set;}
/// <summary>
/// Bounds represents how close we must get to the node to complete it.
/// Some tasks require multiple actions within Bounds to be marked as complete.
/// </summary>
publicintBounds{get;set;}

/// <summary>
/// Counts the number of times the Task has been executed. Used for canceling invalid actions
/// </summary>
publicintAttemptCount{get;set;}


publicTaskNode(Vector3position,intbounds,TaskNodeTypetype=TaskNodeType.Movement)
{
WorldPosition=position;
Type=type;
Bounds=bounds;
}
}
}