void Update()
{
hitByRay.Clear();
var hits = RayCastUtil.RayHitsFromCamera(layerMask);
bool first = true;
foreach (RayHitInfo hit in hits)
{
hitByRay.Add(hit.Hit, hit.hitPos);
if (first)
{
HitFirst = hit;
first = false;
}
if (hit.Hit.ShutOutRay)
{
break;
}
}
if (first)
{
HitFirst = null;
}
}
public RayHitInfo(RayHitInfo copyInfo)
{
this.HitType = copyInfo.HitType;
this.ClosestHitObject = copyInfo.ClosestHitObject;
this.HitPosition = copyInfo.HitPosition;
this.NormalAtHit = copyInfo.NormalAtHit;
this.DistanceToHit = copyInfo.DistanceToHit;
}
//We're just treating gun as a single raycaster, but making a multiraycaster should be very easy
public RayHitInfo ServerShoot(Gunfish gunfish)
{
rb = gunfish.rb;
RayHitInfo rayHitInfo = new RayHitInfo();
float angle = NetworkManager.singleton.client.GetRTT() / 1000f * rb.angularVelocity;
Vector3 deltaPos = NetworkManager.singleton.client.GetRTT() / 1000f * rb.velocity;
//float x = Mathf.Tan(angle * Mathf.Deg2Rad);
Vector3 point = barrelPoint.transform.right; // + barrelPoint.transform.up * x;
Ray ray = new Ray(barrelPoint.transform.position + deltaPos, point); //- barrelPoint.transform.position);
RaycastHit2D rayHit = Physics2D.Raycast(ray.origin, ray.direction, shotInfo.distance);
if (rayHit)
{
GameObject hit = rayHit.collider.gameObject;
//if gunfish
if (hit.CompareTag("Gunfish"))
{
rayHitInfo.netId = hit.GetComponentInParent <Gunfish>().netId;
rayHitInfo.color = Color.red;
rayHitInfo.hitType = HitType.Fish;
}
//if generic object
else if (hit.CompareTag("Ground"))
{
//rayHitInfo.netId.Value defaults to zero
rayHitInfo.color = hit.gameObject.GetComponent <SpriteRenderer>().color;
rayHitInfo.hitType = HitType.Wood;
}
else if (hit.CompareTag("Object"))
{
rayHitInfo.color = hit.gameObject.GetComponent <SpriteRenderer>().color;
rayHitInfo.hitType = HitType.Wood;
if (hit.GetComponent <Rigidbody2D>())
{
hit.GetComponent <Rigidbody2D>().AddForce(-rayHit.normal * shotInfo.force);
}
}
rayHitInfo.normal = rayHit.normal;
rayHitInfo.end = rayHit.point;
}
else
{
//if nothing was hit
rayHitInfo.netId = NetworkInstanceId.Invalid;
rayHitInfo.end = barrelPoint.transform.position + (transform.right * shotInfo.distance);
}
rayHitInfo.origin = barrelPoint.transform.position;
rayHitInfo.shotType = shotType;
return(rayHitInfo);
}
public bool UseBaseAttack(RayHitInfo hit_info)
{
if (Vector3.Distance(hit_info.hit_point, (transform.position + Vector3.up * 1.5f)) < 2)
{
CastSkill(SkillButton.LMB, hit_info);
return(true);
}
return(false);
}
public static ObjectInstance Object(RayHitInfo input)
{
var output = JS.instance.engine.Object.Construct();
output["hit"] = input.hit != 0;
output["distance"] = (double)input.distance;
output["position"] = Object(input.position);
output["normal"] = Object(input.normal);
return(output);
}
private void HandleHitInfo(RayHitInfo rayHitInfo)
{
if (rayHitInfo.netId != NetworkInstanceId.Invalid)
{
EffectsManager.instance.DisplayBulletHit(rayHitInfo.end, rayHitInfo.normal, rayHitInfo.color, rayHitInfo.hitType);
if (ownedGunfish && rayHitInfo.netId == ownedGunfish.netId)
{
ownedGunfish.Hit((rayHitInfo.end - rayHitInfo.origin).normalized, rayHitInfo.shotType);
}
}
EffectsManager.instance.DisplayBulletLine(rayHitInfo.origin, rayHitInfo.end, ownedGunfish.gun.shotTrailColor);
}
public void OnGunshot(NetworkMessage netMsg)
{
GunfishMsg msg = netMsg.ReadMessage <GunfishMsg>();
//Get the gunfish, tell it to shoot, and get the hit information
Gunfish gunfish = NetworkServer.FindLocalObject(msg.netId).GetComponent <Gunfish>();
//Presuming our gun is a single raycaster
RayHitInfo rayHitInfo = gunfish.ServerShoot(gunfish);
NetworkServer.SendToAll(MessageTypes.RAYHIT, new RayHitMsg(rayHitInfo));
//This message handles gunshot audio and muzzle flash
NetworkServer.SendToAll(MessageTypes.GUNSHOT, new GunfishMsg(msg.netId));
}
public static ObjectInstance GetCollisionRayModel(ObjectInstance ray, ObjectInstance position, ObjectInstance rotation, string modelPath)
{
var rayo = Disaster.TypeInterface.Ray(ray);
var model = Disaster.Assets.Model(modelPath);
var transform = new Disaster.Transformation(Disaster.TypeInterface.Vector3(position), Disaster.TypeInterface.Vector3(rotation), Vector3.One).ToMatrix();
Matrix4x4.Invert(transform, out Matrix4x4 inverse);
rayo.position = Vector3.Transform(rayo.position, inverse);
rayo.direction = Vector3.TransformNormal(rayo.direction, inverse);
//model.transform = transform;
RayHitInfo output = Raylib.GetCollisionRayModel(rayo, model);
//model.transform = Matrix4x4.Identity;
return(Disaster.TypeInterface.Object(output));
}
public void CastSkill(SkillButton skill_index, RayHitInfo hit_info)
{
if (equip_skills[(int)skill_index].IsOnCooldown())
{
StartCoroutine(SkillOnCDDisplay());
return;
}
if (cast_timer > 0)
{
Debug.Log("Already casting a skill");
}
else
{
if (equip_skills[(int)skill_index].cast_time_mult == 0)
{
cast_timer = 0;
}
else
{
cast_timer = 1 / (equip_skills[(int)skill_index].cast_time_mult * attack_speed.Buffed_value);
}
if (CharacterController.instance.SpendResource(equip_skills[(int)skill_index].cost))
{
CharacterController.instance.move_controller.StopMovement();
if (cast_timer != 0)
{
pc_animator.SetInteger("Weapon", 1);
pc_animator.speed = 1 / cast_timer;
pc_animator.SetTrigger("AttackTrigger");
is_attacking = true;
}
equip_skills[(int)skill_index].CastSkill(GetCastInfo(transform.position, hit_info.hit_point));
transform.rotation = Quaternion.LookRotation(hit_info.hit_point - (transform.position + Vector3.up * 1.5f), Vector3.up);
}
else
{
StartCoroutine(SkillNoMoreManaDisplay());
}
}
}
public unsafe static int Main()
{
// Initialization
//--------------------------------------------------------------------------------------
const int screenWidth = 800;
const int screenHeight = 450;
InitWindow(screenWidth, screenHeight, "raylib [models] example - mesh picking");
// Define the camera to look into our 3d world
Camera3D camera;
camera.position = new Vector3(20.0f, 20.0f, 20.0f); // Camera3D position
camera.target = new Vector3(0.0f, 8.0f, 0.0f); // Camera3D looking at point
camera.up = new Vector3(0.0f, 1.6f, 0.0f); // Camera3D up vector (rotation towards target)
camera.fovy = 45.0f; // Camera3D field-of-view Y
camera.type = CAMERA_PERSPECTIVE; // Camera3D mode type
Ray ray = new Ray(); // Picking ray
Model tower = LoadModel("resources/models/turret.obj"); // Load OBJ model
Texture2D texture = LoadTexture("resources/models/turret_diffuse.png"); // Load model texture
Utils.SetMaterialTexture(ref tower, 0, MAP_ALBEDO, ref texture); // Set map diffuse texture
Vector3 towerPos = new Vector3(0.0f, 0.0f, 0.0f); // Set model position
Mesh * meshes = (Mesh *)tower.meshes.ToPointer();
BoundingBox towerBBox = MeshBoundingBox(meshes[0]); // Get mesh bounding box
bool hitMeshBBox = false;
bool hitTriangle = false;
// Test triangle
Vector3 ta = new Vector3(-25.0f, 0.5f, 0.0f);
Vector3 tb = new Vector3(-4.0f, 2.5f, 1.0f);
Vector3 tc = new Vector3(-8.0f, 6.5f, 0.0f);
Vector3 bary = new Vector3(0.0f, 0.0f, 0.0f);
SetCameraMode(camera, CAMERA_FREE); // Set a free camera mode
SetTargetFPS(60); // Set our game to run at 60 frames-per-second
//----------------------------------------------------------------------------------
// Main game loop
//--------------------------------------------------------------------------------------
while (!WindowShouldClose()) // Detect window close button or ESC key
{
//----------------------------------------------------------------------------------
// Update
//----------------------------------------------------------------------------------
UpdateCamera(ref camera); // Update camera
// Display information about closest hit
RayHitInfo nearestHit = new RayHitInfo();
string hitObjectName = "None";
nearestHit.distance = FLT_MAX;
nearestHit.hit = false;
Color cursorColor = WHITE;
// Get ray and test against ground, triangle, and mesh
ray = GetMouseRay(GetMousePosition(), camera);
// Check ray collision aginst ground plane
RayHitInfo groundHitInfo = GetCollisionRayGround(ray, 0.0f);
if ((groundHitInfo.hit) && (groundHitInfo.distance < nearestHit.distance))
{
nearestHit = groundHitInfo;
cursorColor = GREEN;
hitObjectName = "Ground";
}
// Check ray collision against test triangle
RayHitInfo triHitInfo = GetCollisionRayTriangle(ray, ta, tb, tc);
if ((triHitInfo.hit) && (triHitInfo.distance < nearestHit.distance))
{
nearestHit = triHitInfo;
cursorColor = PURPLE;
hitObjectName = "Triangle";
bary = Vector3Barycenter(nearestHit.position, ta, tb, tc);
hitTriangle = true;
}
else
{
hitTriangle = false;
}
RayHitInfo meshHitInfo = new RayHitInfo();
// Check ray collision against bounding box first, before trying the full ray-mesh test
if (CheckCollisionRayBox(ray, towerBBox))
{
hitMeshBBox = true;
// Check ray collision against model
// NOTE: It considers model.transform matrix!
meshHitInfo = GetCollisionRayModel(ray, tower);
if ((meshHitInfo.hit) && (meshHitInfo.distance < nearestHit.distance))
{
nearestHit = meshHitInfo;
cursorColor = ORANGE;
hitObjectName = "Mesh";
}
}
hitMeshBBox = false;
//----------------------------------------------------------------------------------
// Draw
//----------------------------------------------------------------------------------
BeginDrawing();
ClearBackground(RAYWHITE);
BeginMode3D(camera);
// Draw the tower
// WARNING: If scale is different than 1.0f,
// not considered by GetCollisionRayModel()
DrawModel(tower, towerPos, 1.0f, WHITE);
// Draw the test triangle
DrawLine3D(ta, tb, PURPLE);
DrawLine3D(tb, tc, PURPLE);
DrawLine3D(tc, ta, PURPLE);
// Draw the mesh bbox if we hit it
if (hitMeshBBox)
{
DrawBoundingBox(towerBBox, LIME);
}
// If we hit something, draw the cursor at the hit point
if (nearestHit.hit)
{
DrawCube(nearestHit.position, 0.3f, 0.3f, 0.3f, cursorColor);
DrawCubeWires(nearestHit.position, 0.3f, 0.3f, 0.3f, RED);
Vector3 normalEnd;
normalEnd.X = nearestHit.position.X + nearestHit.normal.X;
normalEnd.Y = nearestHit.position.Y + nearestHit.normal.Y;
normalEnd.Z = nearestHit.position.Z + nearestHit.normal.Z;
DrawLine3D(nearestHit.position, normalEnd, RED);
}
DrawRay(ray, MAROON);
DrawGrid(10, 10.0f);
EndMode3D();
// Draw some debug GUI text
DrawText(string.Format("Hit Object: {0}", hitObjectName), 10, 50, 10, BLACK);
if (nearestHit.hit)
{
int ypos = 70;
var x = string.Format("Distance: {0:000.00}", nearestHit.distance);
DrawText(string.Format("Distance: {0:000.00}", nearestHit.distance), 10, ypos, 10, BLACK);
DrawText(string.Format("Hit Pos: {0:000.00} {1:000.00} {2:000.00}",
nearestHit.position.X,
nearestHit.position.Y,
nearestHit.position.Z), 10, ypos + 15, 10, BLACK);
DrawText(string.Format("Hit Norm: {0:000.00} {1:000.00} {2:000.00}",
nearestHit.normal.X,
nearestHit.normal.Y,
nearestHit.normal.Z), 10, ypos + 30, 10, BLACK);
if (hitTriangle)
{
DrawText(string.Format("Barycenter:{0:000.00} {1:000.00} {2:000.00}", bary.X, bary.Y, bary.Z), 10, ypos + 45, 10, BLACK);
}
}
DrawText("Use Mouse to Move Camera", 10, 430, 10, GRAY);
DrawText("(c) Turret 3D model by Alberto Cano", screenWidth - 200, screenHeight - 20, 10, GRAY);
DrawFPS(10, 10);
EndDrawing();
//----------------------------------------------------------------------------------
}
// De-Initialization
//--------------------------------------------------------------------------------------
UnloadModel(tower); // Unload model
UnloadTexture(texture); // Unload texture
CloseWindow(); // Close window and OpenGL context
//--------------------------------------------------------------------------------------
return(0);
}
// Update is called once per frame
void Update()
{
if (game_over_canvas != null && game_over_canvas.activeSelf)
{
return;
}
//Resource/health regen
if (curr_health < variables_stats[(int)StatId.MaxHealth].Buffed_value)
{
curr_health += variables_stats[(int)StatId.HealthRegen].Buffed_value * Time.deltaTime;
if (curr_health > variables_stats[(int)StatId.MaxHealth].Buffed_value)
{
curr_health = variables_stats[(int)StatId.MaxHealth].Buffed_value;
}
}
if (curr_resource < variables_stats[(int)StatId.MaxResource].Buffed_value)
{
curr_resource += variables_stats[(int)StatId.ResourceRegen].Buffed_value * Time.deltaTime;
if (curr_resource > variables_stats[(int)StatId.MaxResource].Buffed_value)
{
curr_resource = variables_stats[(int)StatId.MaxResource].Buffed_value;
}
}
if (Input.GetKeyUp(KeyCode.Escape))
{
if (skill_controller.GetSkillSelectionUIStatus())
{
skill_controller.ForceSkillSelectioUIStatus(false);
return;
}
if (inventory_canvas.activeSelf)
{
inventory_canvas.SetActive(false);
return;
}
if (character_stats_canvas.activeSelf)
{
character_stats_canvas.SetActive(false);
return;
}
if (main_menu_canvas != null)
{
main_menu_canvas.SetActive(!main_menu_canvas.activeSelf);
}
}
if (main_menu_canvas.activeSelf)
{
return;
}
if (Input.GetKeyUp(KeyCode.I))
{
inventory_canvas.SetActive(!inventory_canvas.activeSelf);
}
if (Input.GetKeyUp(KeyCode.C))
{
character_stats_canvas.SetActive(!character_stats_canvas.activeSelf);
}
//Don't read inputs if UI active
if (inventory_canvas.activeSelf || character_stats_canvas.activeSelf || skill_controller.skill_selection_UI.activeSelf)
{
return;
}
//Read game inputs
if (Input.GetMouseButton(0) && !Input.GetKey(KeyCode.LeftShift))
{
Debug.Log("Processing Left Click");
int mask = LayerMask.GetMask("Floor", "Enemy", "Item");
RayHitInfo ray_hit = RayCastHandle(Input.mousePosition, mask);
if (ray_hit.hitted)
{
if (ray_hit.layer_hit == LayerMask.NameToLayer("Floor"))
{
Debug.Log("moving with the floor");
move_controller.MoveToPosition(ray_hit.hit_point);
}
else if (ray_hit.layer_hit == LayerMask.NameToLayer("Enemy"))
{
Debug.Log("Enemy Attacked");
if (!skill_controller.UseBaseAttack(ray_hit))
{
move_controller.MoveToEnemy(ray_hit.go_hit.transform);
}
}
else if (ray_hit.layer_hit == LayerMask.NameToLayer("Item"))
{
Debug.Log("picking the item");
ray_hit.go_hit.GetComponent <ItemWorld>().to_pick = true;
move_controller.MoveToPosition(ray_hit.hit_point);
}
}
}
if (Input.GetMouseButtonDown(0) && Input.GetKey(KeyCode.LeftShift))
{
RayHitInfo ray_hit = RayCastHandle(Input.mousePosition, LayerMask.GetMask("Floor", "Enemy"));
if (ray_hit.hitted)
{
skill_controller.CastSkill(SkillButton.LMB, ray_hit);
}
}
if (Input.GetMouseButtonDown(1))
{
RayHitInfo ray_hit = RayCastHandle(Input.mousePosition, LayerMask.GetMask("Floor", "Enemy"));
if (ray_hit.hitted)
{
skill_controller.CastSkill(SkillButton.RMC, ray_hit);
}
}
if (Input.GetKeyUp(KeyCode.Alpha1))
{
RayHitInfo ray_hit = RayCastHandle(Input.mousePosition, LayerMask.GetMask("Floor", "Enemy"));
if (ray_hit.hitted)
{
skill_controller.CastSkill(SkillButton.NUM_1, ray_hit);
}
}
if (Input.GetKeyUp(KeyCode.Alpha2))
{
RayHitInfo ray_hit = RayCastHandle(Input.mousePosition, LayerMask.GetMask("Floor", "Enemy"));
if (ray_hit.hitted)
{
skill_controller.CastSkill(SkillButton.NUM_2, ray_hit);
}
}
if (Input.GetKeyUp(KeyCode.Alpha3))
{
RayHitInfo ray_hit = RayCastHandle(Input.mousePosition, LayerMask.GetMask("Floor", "Enemy"));
if (ray_hit.hitted)
{
skill_controller.CastSkill(SkillButton.NUM_3, ray_hit);
}
}
if (Input.GetKeyUp(KeyCode.Alpha4))
{
RayHitInfo ray_hit = RayCastHandle(Input.mousePosition, LayerMask.GetMask("Floor", "Enemy"));
if (ray_hit.hitted)
{
skill_controller.CastSkill(SkillButton.NUM_4, ray_hit);
}
}
if (Input.GetKeyDown(KeyCode.F1))
{
invincible = !invincible;
invincible_display.SetActive(invincible);
}
if (Input.GetKeyDown(KeyCode.F2))
{
no_mana_cost = !no_mana_cost;
no_mana_display.SetActive(no_mana_cost);
}
}
public RayHitMsg(RayHitInfo hitInfo)
{
this.rayHitInfo = hitInfo;
}
