How do you flip the bullet trail prefab, so it shoots the way you are facing and how do you make the bullets disappear when they hit a platform?

I am new to Unity and C# and I am following a 2D tutorial made by Brackeys. I am up to video number 9, when I got stuck.
Instead of the bullet following the mouse, I want it to just shoot the way the player is facing. I can get the bullet to shoot to the right, but when my player turns around the bullet still shoots to the right.

As for my second question. When the bullets shoot to the right they just go behind the platform and come out on the other side. The game does come up with the message saying that it did hit the platform. But it just goes straight through.
I have looked at many forum pages but I can’t fix either of the problems. Like I said at the start I am new the Unity and C# so I could be just overlooking something that is very easy.
Thank you in advance

Here is the code I am using from the tutorial.

Player script:

using System;
using UnityEngine;

namespace UnityStandardAssets._2D
{
public class PlatformerCharacter2D : MonoBehaviour
{
[SerializeField] private float m_MaxSpeed = 10f; // The fastest the player can travel in the x axis.
[SerializeField] private float m_JumpForce = 400f; // Amount of force added when the player jumps.
[Range(0, 1)] [SerializeField] private float m_CrouchSpeed = .36f; // Amount of maxSpeed applied to crouching movement. 1 = 100%
[SerializeField] private bool m_AirControl = false; // Whether or not a player can steer while jumping;
[SerializeField] private LayerMask m_WhatIsGround; // A mask determining what is ground to the character

    private Transform m_GroundCheck;    // A position marking where to check if the player is grounded.
    const float k_GroundedRadius = .2f; // Radius of the overlap circle to determine if grounded
    private bool m_Grounded;            // Whether or not the player is grounded.
    private Transform m_CeilingCheck;   // A position marking where to check for ceilings
    const float k_CeilingRadius = .01f; // Radius of the overlap circle to determine if the player can stand up
    private Animator m_Anim;            // Reference to the player's animator component.
    private Rigidbody2D m_Rigidbody2D;
    private bool m_FacingRight = true;  // For determining which way the player is currently facing.

    private void Awake()
    {
        // Setting up references.
        m_GroundCheck = transform.Find("GroundCheck");
        m_CeilingCheck = transform.Find("CeilingCheck");
        m_Anim = GetComponent<Animator>();
        m_Rigidbody2D = GetComponent<Rigidbody2D>();
    }

    private void FixedUpdate()
    {
        m_Grounded = false;

        // The player is grounded if a circlecast to the groundcheck position hits anything designated as ground
        // This can be done using layers instead but Sample Assets will not overwrite your project settings.
        Collider2D[] colliders = Physics2D.OverlapCircleAll(m_GroundCheck.position, k_GroundedRadius, m_WhatIsGround);
        for (int i = 0; i < colliders.Length; i++)
        {
            if (colliders*.gameObject != gameObject)*

m_Grounded = true;
}
m_Anim.SetBool(“Ground”, m_Grounded);
// Set the vertical animation
m_Anim.SetFloat(“vSpeed”, m_Rigidbody2D.velocity.y);
}
public void Move(float move, bool crouch, bool jump)
{
// If crouching, check to see if the character can stand up
if (!crouch && m_Anim.GetBool(“Crouch”))
{
// If the character has a ceiling preventing them from standing up, keep them crouching
if (Physics2D.OverlapCircle(m_CeilingCheck.position, k_CeilingRadius, m_WhatIsGround))
{
crouch = true;
}
}
// Set whether or not the character is crouching in the animator
m_Anim.SetBool(“Crouch”, crouch);
//only control the player if grounded or airControl is turned on
if (m_Grounded || m_AirControl)
{
// Reduce the speed if crouching by the crouchSpeed multiplier
move = (crouch ? movem_CrouchSpeed : move);
// The Speed animator parameter is set to the absolute value of the horizontal input.
m_Anim.SetFloat(“Speed”, Mathf.Abs(move));
// Move the character
m_Rigidbody2D.velocity = new Vector2(movem_MaxSpeed, m_Rigidbody2D.velocity.y);

// If the input is moving the player right and the player is facing left…
if (move > 0 && !m_FacingRight)
{
// … flip the player.
Flip();
}
// Otherwise if the input is moving the player left and the player is facing right…
else if (move < 0 && m_FacingRight)
{
// … flip the player.
Flip();
}
}
// If the player should jump…
if (m_Grounded && jump && m_Anim.GetBool(“Ground”))
{
// Add a vertical force to the player.
m_Grounded = false;
m_Anim.SetBool(“Ground”, false);
m_Rigidbody2D.AddForce(new Vector2(0f, m_JumpForce));
}
}
private void Flip()
{
// Switch the way the player is labelled as facing.
m_FacingRight = !m_FacingRight;
// Multiply the player’s x local scale by -1.
Vector3 theScale = transform.localScale;
theScale.x *= -1;
transform.localScale = theScale;
}
}
}
Weapon Script
float timeToFire = 0;
Transform firePoint;
private bool facingRight;
// Use this for initialization
void Awake()
{
firePoint = transform.FindChild(“FirePoint”);
if (firePoint == null)
{
Debug.LogError(“No firepoint? WHAT?!”);
}
endPoint = transform.FindChild(“EndPoint”);
if (firePoint == null)
{
Debug.LogError(“No endpoint? What?1”);
}
}
// Update is called once per frame
void Update()
{
if (fireRate == 0)
{
if (Input.GetButtonDown(“Fire1”))
{
Shoot();
}
}
else
{
if (Input.GetButton(“Fire1”) && Time.time > timeToFire)
{
timeToFire = Time.time + 1 / fireRate;
Shoot();
}
}
}
void Shoot()
{
Vector2 endPosition = new Vector2(endPoint.position.x, endPoint.position.y);
Vector2 firePointPosition = new Vector2(firePoint.position.x, firePoint.position.y);
RaycastHit2D hit = Physics2D.Raycast(firePointPosition, endPosition - firePointPosition, 100, whatToHit);
Effect();
Debug.DrawLine(firePointPosition, (endPosition - firePointPosition) * 100, Color.cyan);
if (hit.collider != null)
{
Debug.DrawLine(firePointPosition, hit.point, Color.red);
Debug.Log(“We hit” + hit.collider.name + " and did " + Damage + " damage.");
}
}
void Effect () {
Instantiate(BulletTrailPrefab, endPoint.position, endPoint.rotation);
}
}
Move trail script
using UnityEngine;
using System.Collections;
public class MoveTrail : MonoBehaviour {
public int moveSpeed = 230;
private Vector2 direction;

// Update is called once per frame

  • void Update () {*
    transform.Translate (Vector2.right * Time.deltaTime * moveSpeed);
    Destroy(gameObject, 1);
  • }*
    }

For your WeaponScript, you just need your PlayerScript to expose its m_FacingRight field (I’d make it a property, but do what you want). Then you’d be able to know which way the player is facing. Right now, the WeaponScript has its own facingRight field which is independent of PlayerScript and is therefore meaningless. Anyway, you said you had figured out how to make it shoot right. Is that the code you’re showing us now?

This is for your MoveTrailScript:

 public int moveSpeed = 230;
 private Vector2 direction;
 [SerializeField]
 private LayerMask wallLayerMask;
 
 void Awake() {
     RaycastHit2D hit = Physics2D.Raycast(transform.position, direction, moveSpeed, wallLayerMask);
     if (hit)
     {
         Destroy(gameObject, hit.fraction);
     }
     else
     {
         Destroy(gameObject, 1);
     }
 }

 // Update is called once per frame
 void Update () {
     transform.Translate (Vector2.right * Time.deltaTime * moveSpeed);
 }

Explanation:
The bullet raycasts ahead of its direction.
If it finds a collider with the layer “wallLayerMask”, hit returns true.
hit.fraction is the distance along the ray the collider hit.
This means that if hit.fraction returns 1, the collider hit at the end of the ray.
The ray only travels 230 units, because the trail is only supposed to move for a second.
The moveSpeed is the same as the distance the ray travels, since it’s set to move for a second.
The object is set to be destroyed after hit.fraction seconds, because the full length of the ray is travelled in one second.