void Start()
{
state = new PlayerFallingState();
collision_detector = this.gameObject.GetComponent <CollisionDetector>();
radius = 0.05f;
jump_request = -100;
}
public bool Jump()
{
if (grounded)
{
Vector3 normal = ground.data.arc.EvaluateNormal(ground.data.angle);
phi = Mathf.Acos(current_position.y); //TODO: Transform2sD.SphericalPosition
theta = Mathf.Atan2(current_position.z, current_position.x); //FIXME: magic numbers
Transform camera_transform = GameObject.Find("MainCamera").transform; //FIXME: JANK
Vector3 input3D = new Vector3(input.x, input.y, 0f);
input3D = camera_transform.rotation * input3D;
input3D = Vector3.ProjectOnPlane(input3D, normal);
if (input3D.sqrMagnitude > 1)
{
input3D.Normalize();
}
horizontal_velocity = -0.1f * Vector3.Dot(East, normal) + -0.1f * Vector3.Dot(East, input3D);
vertical_velocity = -0.1f * Vector3.Dot(North, normal) + -0.1f * Vector3.Dot(North, input3D);
ground = new optional <GroundInfo>();
current_position = (current_position + normal * 1e-6f).normalized;
}
state = new PlayerFallingState();
return(grounded);
}
public bool Traverse(ArcOfSphere path, Vector3 desiredPos) //I don't like these parameters, they can be fixed //I don't like that this is public, it should be private and exposed via a generic move option if possible
{
optional <float> interpolation_factor = path.CartesianToRadial(desiredPos);
if (interpolation_factor.exists)
{
ground = new GroundInfo();
ground.data.angle = interpolation_factor.data;
ground.data.arc = path;
ground.data.block = path.GetComponentInParent <Block>();
ground.data.height = path.LengthRadius(radius);
ground.data.begin = path.Begin(radius);
ground.data.end = path.End(radius);
current_position = ArcOfSphere.Evaluate(ground.data, radius);
}
else
{
Debug.Log("Critical Failure: Traverse's interpolation factor doesn't exist!");
}
return(interpolation_factor.exists);
}
public bool LandingTransitionState(CharacterMotor self)
{
if (!self.collision_detector.exists)
{
return(false);
}
//Calculate collision information
optional <ArcOfSphere> arc = self.collision_detector.data.ArcCast(self.current_position, self.previous_position, self.radius);
if (arc.exists)
{
optional <Vector3> collision_point = arc.data.Intersect(self.current_position, self.previous_position, self.radius);
if (collision_point.exists)
{
return(self.Traverse(arc.data, collision_point.data));
}
else
{
Debug.Log("Didn't collide?");
}
}
return(false);
}
public static Mesh OctahedronMesh()
{
if (octahedron.exists)
{
return(octahedron.data);
}
else
{
octahedron = new Mesh();
Vector3[] verts = new Vector3[9];
Vector2[] uvs = new Vector2[9];
int[] tris = new int[3 * 8];
verts[0] = Vector3.up;
verts[1] = Vector3.right;
verts[2] = Vector3.forward;
verts[3] = Vector3.left;
verts[4] = Vector3.back;
verts[5] = Vector3.down;
verts[6] = Vector3.down;
verts[7] = Vector3.down;
verts[8] = Vector3.down;
uvs[0] = new Vector2(0.5f, 0.5f); // up
uvs[1] = new Vector2(1.0f, 0.5f); // right
uvs[2] = new Vector2(0.5f, 0.0f); // forward
uvs[3] = new Vector2(0.0f, 0.5f); // left
uvs[4] = new Vector2(0.5f, 1.0f); // back
uvs[5] = new Vector2(1.0f, 0.0f); // down
uvs[6] = new Vector2(0.0f, 0.0f); // down
uvs[7] = new Vector2(0.0f, 1.0f); // down
uvs[8] = new Vector2(1.0f, 1.0f); // down
tris[0] = 0; tris[1] = 1; tris[2] = 2; //+x, +y, +z
tris[3] = 0; tris[4] = 2; tris[5] = 3; //-x, +y, +z
tris[6] = 0; tris[7] = 3; tris[8] = 4; //-x, +y, -z
tris[9] = 0; tris[10] = 4; tris[11] = 1; //+x, +y, -z
tris[12] = 5; tris[13] = 2; tris[14] = 1; //+x, -y, +z
tris[15] = 6; tris[16] = 3; tris[17] = 2; //-x, -y, +z
tris[18] = 7; tris[19] = 4; tris[20] = 3; //-x, -y, -z
tris[21] = 8; tris[22] = 1; tris[23] = 4; //+x, -y, -z
octahedron.data.vertices = verts;
octahedron.data.uv = uvs;
octahedron.data.triangles = tris;
octahedron.data.RecalculateBounds();
octahedron.data.RecalculateNormals();
;
return(octahedron.data);
}
}
protected override void ExitNexus(CharacterMotor motor) //JANK naming scheme (Note: motor.ExitNexus())
{
//TODO: check if function is complete
motor.ExitNexus();
CollisionDetector detector = motor.GetComponent <CollisionDetector>();
detector.Activate();
optional <ArcOfSphere> closest_arc = detector.BalloonCast(motor.current_position, motor.radius + 0.01f); //FIXME: magic number
if (!closest_arc.exists)
{
Debug.Log("Something is very wrong here");
}
motor.Traverse(closest_arc.data, closest_arc.data.ClosestPoint(motor.current_position));
Destroy(this.gameObject);
}
public override optional <float> Distance(Vector3 to, Vector3 from, float radius) //distance is Euclidean but is (guaranteed?) to be sorted correctly with the current assertions about speed vs player_radius
{
optional <Vector3> point = SphereUtility.Intersection(from, to, Center(radius), AngularRadius(radius));
optional <float> intersection = new optional <float>();
if (point.exists)
{
intersection = CartesianToRadial(point.data);
}
if (intersection.exists)
{
float angle = intersection.data;
Vector3 new_position = Evaluate(angle, radius);
return((from - new_position).sqrMagnitude); //CONSIDER: does Cartesian distance matter?
}
return(new optional <float>());
}
private static void AugmentDictionary()
{
start_edge_map = new SortedList <float, QuadraticBezier>();
end_edge_map = new SortedList <float, QuadraticBezier>();
//create quick map for locating consecutive QB's on edge of square
for (int index = 0; index < start_discontinuities.Count; ++index)
{
start_edge_map.Add(EdgeMapKey(start_discontinuities[index].end_UV), start_discontinuities[index]);
DebugUtility.Log("start_edge_map", EdgeMapKey(start_discontinuities[index].end_UV));
}
for (int index = 0; index < end_discontinuities.Count; ++index)
{
end_edge_map.Add(EdgeMapKey(end_discontinuities[index].begin_UV), end_discontinuities[index]);
DebugUtility.Log("end_edge_map", EdgeMapKey(end_discontinuities[index].begin_UV));
}
optional <QuadraticBezier> last_bezier = GetFirstDiscontinuity();
optional <QuadraticBezier> this_bezier = GetSecondDiscontinuity();
optional <QuadraticBezier> first_bezier = last_bezier;
while (true) // TODO: clean up / make pretty / make elegant
{
Debug.Log(last_bezier);
Debug.Log(this_bezier);
if (last_bezier.exists && this_bezier.exists)
{
StitchTogether(last_bezier.data, this_bezier.data);
}
last_bezier = NextDiscontinuity();
this_bezier = NextDiscontinuity();
if (last_bezier == first_bezier || this_bezier == first_bezier)
{
break;
}
}
}
private static void StitchTogether(QuadraticBezier cursor, QuadraticBezier last)
{
if (swapped)
{
QuadraticBezier swapper = cursor;
cursor = last;
last = swapper;
}
DebugUtility.Log("Stitching:", cursor.end_UV, last.begin_UV);
float cursor_key = EdgeMapKey(cursor.end_UV);
float last_key = EdgeMapKey(last.begin_UV);
bool clockwise = Vector3.Dot(ClockwiseDirection(cursor_key),
-cursor.arc.EvaluateRight(cursor.end)) > 0; // left for start_edge_map/end because right DNE
// add edges that weren't added by BuildDictionary (along the square (0,0) -> (1,0) -> (1,1) -> (0,1) )
optional <Vector2> corner = NextCorner(cursor_key, last_key, clockwise);
Vector2 control_point;
QuadraticBezier intermediate_line;
while (corner.exists)
{
Debug.Log(corner);
control_point = (cursor.end_UV + corner.data) / 2;
intermediate_line = new QuadraticBezier(null, cursor.end_UV, control_point, corner.data, -1f, -1f);
edge_pattern.Add(cursor, intermediate_line);
cursor = intermediate_line;
cursor_key = EdgeMapKey(cursor.end_UV);
corner = NextCorner(cursor_key, last_key, clockwise);
}
control_point = (cursor.end_UV + last.begin_UV) / 2;
intermediate_line = new QuadraticBezier(null, cursor.end_UV, control_point, last.begin_UV, -1f, -1f);
edge_pattern.Add(cursor, intermediate_line);
edge_pattern.Add(intermediate_line, last);
}
public optional <ArcOfSphere> BalloonCast(Vector3 desired_position, float max_radius) //TODO: see if ArcCast can be combined to reduce redundancy //HACK: may not work for all or even most cases
{
optional <ArcOfSphere> closest = new optional <ArcOfSphere>();
optional <Vector3> closest_point = new optional <Vector3>();
//Step 1: go through each colliding arc
foreach (ArcOfSphere arc in colliders)
{
//step 2: ask the block if a collision actually occuring in Spherical coordinates
if (arc.Contains(desired_position, max_radius))
{
//step 3: if a collision is happening, find the closest collision point and compare it to the closest so far
Vector3 point = arc.ClosestPoint(desired_position);
if (!closest_point.exists || (point - desired_position).sqrMagnitude < (closest_point.data - desired_position).sqrMagnitude)
{
closest_point = point;
closest = arc;
}
}
}
//step 4: the player moves in contact with the object and performs camera transitions accordingly if there was a collision.
return(closest);
}
//CONSIDER: Can you "inversion of control" ArcCast and BalloonCast?
public optional <ArcOfSphere> ArcCast(Vector3 desired_position, Vector3 current_position, float radius) //Not actually a true ArcCast, I'm not planned on spending 3 months on R&D'ing it either
{
optional <ArcOfSphere> closest = new optional <ArcOfSphere>();
optional <float> closest_distance = new optional <float>();
//Step 1: go through each colliding arc
foreach (ArcOfSphere arc in colliders)
{
//step 2: Character Controller asks the block if a collision actually occuring in Spherical coordinates
if (arc.Contains(desired_position, radius))
{
//step 3: if a collision is happening, a list of TTCs (time till collision) are sorted to find the closest collision.
optional <float> distance = arc.Distance(desired_position, current_position, radius);
if (distance.exists && (!closest_distance.exists || distance.data < closest_distance.data))
{
closest_distance = distance;
closest = arc;
}
}
}
//step 4: the player moves in contact with the object and performs camera transitions accordingly if there was a collision.
return(closest); //charMotor.Traverse(closest, desiredPos, curPosition);
}
public void AddDamage(HitType hitType, int damage, optional InfluenceType influenceType, optional Actor attacker); // RVA: 0x69DFB8 Offset: 0x69DFB8
/** Find the point of collision with an arc.
*/
public optional <Vector3> Intersect(Vector3 to, Vector3 from, float radius)
{
optional <Vector3> result = SphereUtility.Intersection(from, to, Pole(), AngularRadius(radius));
return(result);
}
// ARM Offset: 0x4D37D8
// ARM64 Offset: 0x81B768
// x86 Offset: 0x484DF0
public bool isDiaEnough(int need, optional GameObject call, optional s_t_item item, optional string Okmessage, optional string Nomessage);
public void ExitNexus()
{
connection = new optional <Nexus>();
}
public void EnterNexus(Nexus _connection)
{
connection = _connection;
this.GetComponent <CollisionDetector>().Deactivate(); //TODO: UNJANKIFY?
ground = new optional <GroundInfo>();
}
internal AIMLTagHandler GetTagHandlerU(User user, SubQuery query, Request request, Result result, XmlNode node, bool liText)
{
AIMLTagHandler tagHandlerU = getBespokeTags(user, query, request, result, node);
string nodeNameLower = StaticAIMLUtils.ToLower(node.LocalName);
AltBot targetBot = query.TargetBot;
if (Equals(null, tagHandlerU))
{
switch (nodeNameLower)
{
case "template":
case "answer": //CML
tagHandlerU = new template(targetBot, user, query, request, result, node);
break;
case "aiml":
case "cml": //CML
tagHandlerU = new aiml(targetBot, user, query, request, result, node);
break;
case "aimlexec":
case "eval":
tagHandlerU = new aimlexec(targetBot, user, query, request, result, node);
break;
case "vars":
case "root":
case "predicates": //CML
tagHandlerU = new root(targetBot, user, query, request, result, node, (() => query.TargetSettings));
break;
case "properties":
case "bots":
tagHandlerU = new root(targetBot, user, query, request, result, node,
(() => request.TargetBot.GlobalSettings));
break;
case "substitutions":
tagHandlerU = new root(targetBot, user, query, request, result, node,
(() => request.TargetBot.InputSubstitutions));
break;
case "topic":
case "conversation": //CML
tagHandlerU = new topic(targetBot, user, query, request, result, node);
break;
case "category":
case "conv": //CML
tagHandlerU = new category(targetBot, user, query, request, result, node);
break;
case "and":
tagHandlerU = new and(targetBot, user, query, request, result, node);
break;
case "or":
tagHandlerU = new or(targetBot, user, query, request, result, node);
break;
case "optional":
tagHandlerU = new optional(targetBot, user, query, request, result, node);
break;
case "isa":
tagHandlerU = new isa(targetBot, user, query, request, result, node);
break;
case "bot":
tagHandlerU = new bot(targetBot, user, query, request, result, node);
break;
case "condition":
case "options": //cml
tagHandlerU = new condition_aima(targetBot, user, query, request, result, node);
break;
case "li":
if (liText)
{
tagHandlerU = new liif(targetBot, user, query, request, result, node);
}
break;
case "if":
tagHandlerU = new liif(targetBot, user, query, request, result, node);
break;
case "personf":
tagHandlerU = new format(targetBot, user, query, request, result, node,
new Func <string, string>(HttpUtility.UrlEncode),
null);
break;
case "date":
tagHandlerU = new date(targetBot, user, query, request, result, node);
break;
case "formal":
tagHandlerU = new formal(targetBot, user, query, request, result, node);
break;
case "gender":
tagHandlerU = new gender(targetBot, user, query, request, result, node);
break;
case "get":
tagHandlerU = new get(targetBot, user, query, request, result, node);
break;
case "gossip":
tagHandlerU = new gossip(targetBot, user, query, request, result, node);
break;
case "get_ip":
case "id":
tagHandlerU = new id(targetBot, user, query, request, result, node);
break;
case "inputreq":
tagHandlerU = new inputreq(targetBot, user, query, request, result, node);
break;
case "request":
tagHandlerU = new input(targetBot, user, query, request, result, node, 1);
break;
case "input":
tagHandlerU = new input(targetBot, user, query, request, result, node, 1);
break;
case "justthat": // <input index="2"/>
tagHandlerU = new input(targetBot, user, query, request, result, node, 2);
break;
case "beforethat": // <input index="3"/>
tagHandlerU = new input(targetBot, user, query, request, result, node, 3);
break;
#if !(__MonoCS__)
case "javascript":
tagHandlerU = new javascript(targetBot, user, query, request, result, node);
break;
#endif
case "learn":
case "load":
case "noload": // the commented version of <load>
tagHandlerU = new learn(targetBot, user, query, request, result, node);
break;
case "lowercase":
tagHandlerU = new lowercase(targetBot, user, query, request, result, node);
break;
case "person":
tagHandlerU = new substitute(targetBot, user, query, request, result, node);
break;
case "person2":
tagHandlerU = new substitute(targetBot, user, query, request, result, node);
break;
case "random":
tagHandlerU = new random(targetBot, user, query, request, result, node);
break;
case "sentence":
tagHandlerU = new sentence(targetBot, user, query, request, result, node);
break;
case "set":
tagHandlerU = new set(targetBot, user, query, request, result, node);
break;
case "size":
case "getsize":
tagHandlerU = new size(targetBot, user, query, request, result, node);
break;
case "sr":
tagHandlerU = new sr(targetBot, user, query, request, result, node);
break;
case "srai_odd":
tagHandlerU = new srai_odd(targetBot, user, query, request, result, node);
break;
case "star":
tagHandlerU = new star(targetBot, user, query, request, result, node);
break;
case "system":
tagHandlerU = new system(targetBot, user, query, request, result, node);
break;
case "that": //default <that index="1,1"/>
tagHandlerU = new that(targetBot, user, query, request, result, node, 1);
break;
case "justbeforethat": //treated as <that index="2,1"/>
tagHandlerU = new that(targetBot, user, query, request, result, node, 2);
break;
case "response": //treated as <that index="1,1"/>
tagHandlerU = new that(targetBot, user, query, request, result, node, 2);
break;
case "thatstar":
tagHandlerU = new thatstar(targetBot, user, query, request, result, node);
break;
case "think":
tagHandlerU = new think(targetBot, user, query, request, result, node);
break;
case "topicstar":
tagHandlerU = new topicstar(targetBot, user, query, request, result, node);
break;
case "uppercase":
tagHandlerU = new uppercase(targetBot, user, query, request, result, node);
break;
case "version":
case "getversion":
tagHandlerU = new version(targetBot, user, query, request, result, node);
break;
case "cycsystem":
tagHandlerU = new cycsystem(targetBot, user, query, request, result, node);
break;
case "cycretract":
tagHandlerU = new cycretract(targetBot, user, query, request, result, node);
break;
case "cycassert":
tagHandlerU = new cycassert(targetBot, user, query, request, result, node);
break;
case "cycterm":
tagHandlerU = new cycterm(targetBot, user, query, request, result, node);
break;
case "cycquery":
tagHandlerU = new cycquery(targetBot, user, query, request, result, node);
break;
case "cyccondition":
tagHandlerU = new cyccondition(targetBot, user, query, request, result, node);
break;
case "cycphrase":
tagHandlerU = new cycphrase(targetBot, user, query, request, result, node);
break;
case "cycparaphrase":
tagHandlerU = new cycphrase(targetBot, user, query, request, result, node);
break;
case "guard":
tagHandlerU = new guard(targetBot, user, query, request, result, node);
break;
case "guardstar":
tagHandlerU = new guardstar(targetBot, user, query, request, result, node);
break;
case "cycrandom":
tagHandlerU = new cycrandom(targetBot, user, query, request, result, node);
break;
case "tscore":
tagHandlerU = new tscore(targetBot, user, query, request, result, node);
break;
case "space":
tagHandlerU = new space(targetBot, user, query, request, result, node);
break;
case "markov":
tagHandlerU = new markov(targetBot, user, query, request, result, node);
break;
case "soundcode":
tagHandlerU = new soundcode(targetBot, user, query, request, result, node);
break;
// MSM
case "msm":
tagHandlerU = new msm(targetBot, user, query, request, result, node);
break;
case "processmsm":
tagHandlerU = new process_msm(targetBot, user, query, request, result, node);
break;
case "setstate":
tagHandlerU = new setstate(targetBot, user, query, request, result, node);
break;
case "state":
tagHandlerU = new state(targetBot, user, query, request, result, node);
break;
case "transition":
tagHandlerU = new transition(targetBot, user, query, request, result, node);
break;
case "setevidence":
tagHandlerU = new setevidence(targetBot, user, query, request, result, node);
break;
case "evidenceassoc":
tagHandlerU = new evidence_assoc(targetBot, user, query, request, result, node);
break;
case "evidencepattern":
tagHandlerU = new evidence_pattern(targetBot, user, query, request, result, node);
break;
case "evidencestate":
tagHandlerU = new evidencestate(targetBot, user, query, request, result, node);
break;
case "dependentmachine":
tagHandlerU = new dependentmachine(targetBot, user, query, request, result, node);
break;
case "responsetopic":
tagHandlerU = new response_topic(targetBot, user, query, request, result, node);
break;
case "push":
tagHandlerU = new push(targetBot, user, query, request, result, node);
break;
case "pop":
tagHandlerU = new pop(targetBot, user, query, request, result, node);
break;
case "peekstack":
tagHandlerU = new peekstack(targetBot, user, query, request, result, node);
break;
case "lex":
tagHandlerU = new lex(targetBot, user, query, request, result, node);
break;
case "lexset":
tagHandlerU = new lexset(targetBot, user, query, request, result, node);
break;
case "lexis":
tagHandlerU = new lexis(targetBot, user, query, request, result, node);
break;
case "dbpush":
tagHandlerU = new dbpush(targetBot, user, query, request, result, node);
break;
case "dbquery":
tagHandlerU = new dbquery(targetBot, user, query, request, result, node);
break;
case "dbupdate":
tagHandlerU = new dbupdate(targetBot, user, query, request, result, node);
break;
case "dbdelete":
tagHandlerU = new dbdelete(targetBot, user, query, request, result, node);
break;
case "dbload":
tagHandlerU = new dbload(targetBot, user, query, request, result, node);
break;
case "regex":
tagHandlerU = new regex(targetBot, user, query, request, result, node);
break;
case "bind": // <bind>#$isa</bind>
tagHandlerU = new bind(targetBot, user, query, request, result, node);
break;
case "#text":
if (!liText)
{
return(null);
}
return(new verbatum(node.Value, targetBot, user, query, request, result, node));
case "#comment":
return(new verbatum(node.OuterXml, targetBot, user, query, request, result, node));
case "br":
return(new verbatum("\n", targetBot, user, query, request, result, node));
case "pre":
return(new verbatum(StaticXMLUtils.InnerXmlText(node), targetBot, user, query, request, result, node));
case "p":
return(new verbatum("\n\n", targetBot, user, query, request, result, node));
case "meta":
return(new verbatum(node.OuterXml, targetBot, user, query, request, result, node));
default:
break;
}
}
if (tagHandlerU != null)
{
return(tagHandlerU);
}
if (StaticAIMLUtils.IsHtmlTag(node.Name))
{
return(new recursiveVerbatum(node, targetBot, user, query, request, result, node, true));
}
if (tagHandlerU == null)
{
// "bot", "favorite", "fav"
foreach (KeyValuePair <string, string> prefix in new[]
{
new KeyValuePair <string, string>("get_", "get"),
new KeyValuePair <string, string>("set_", "set"),
new KeyValuePair <string, string>("bot_", "bot"),
new KeyValuePair <string, string>("favorite_", "bot"),
new KeyValuePair <string, string>("favorite", "bot"),
new KeyValuePair <string, string>("fav_", "bot"),
new KeyValuePair <string, string>("fav", "bot"),
new KeyValuePair <string, string>("get", "get"),
new KeyValuePair <string, string>("set", "set"),
new KeyValuePair <string, string>("bot", "bot"),
})
{
if (nodeNameLower.StartsWith(prefix.Key) && node.Name.Length > prefix.Key.Length)
{
string name = node.Name.Substring(prefix.Key.Length);
XmlNode pn = node.ParentNode;
LineInfoElementImpl newnode = StaticXMLUtils.CopyNode(prefix.Value, node, false);
XmlAttributeLineInfo atr = (XmlAttributeLineInfo)newnode.OwnerDocument.CreateAttribute("name");
atr.ReadOnly = false;
atr.Value = name;
newnode.Attributes.Append(atr);
if (node.Name.ToLower() != newnode.Name.ToLower())
{
writeToLog("AIMLLOADER: converted " + node.OuterXml + " -> " + newnode.OuterXml);
return(targetBot.GetTagHandler(newnode, query, request, result, user, liText));
}
writeToLog("AIMLLOADER: ! convert " + node.OuterXml + " -> " + newnode.OuterXml);
}
}
}
if (tagHandlerU != null)
{
return(tagHandlerU);
}
if (nodeNameLower == "name")
{
return(new bot(targetBot, user, query, request, result, node));
}
tagHandlerU = new lazyClosure(targetBot, user, query, request, result, node);
writeToLog("AIMLLOADER: lazyClosure: " + node.OuterXml);
return(tagHandlerU);
}
public bool get_IsAutoCast(); // Patch: 00 00 A0 E3 private bool CanUse(optional bool showMessage, optional bool ignoreTutorialAbility); // Patch: 01 00 A0 E3 1E FF 2F E1
