GunScript

[CATINMASK]

Вот пытаюсь перевести один java скрипт на c#, но никак не получается, помогите кто чем может

Синтаксис:

Синтаксис: [ Показать ]

Используется csharp

using UnityEngine;

using System.Collections;



public class GunScript : MonoBehaviour

{

//Gun Types

enum gunTypes {gun, launcher, sustained, melee}

gunTypes gunType = gunTypes.gun;



//Launcher-Specific Variables

Rigidbody projectile;

float initialSpeed= 20.0f;

int projectileCount = 1;

GameObject launchPosition;



//Gun-Specific Variables

float range= 100.0f;

float force= 10.0f;

float damage= 5.0f;

int shotCount = 6;

bool  burstFire = false;

int burstCount = 1;

float burstTime = .5;

int penetrateVal = 1;

//Sustained Fire (Laser) Specific Variables

float damagePerSecond;

float ammoPerSecond;

float laserRange;

GameObject laserGFX;

static bool  takingOut = false;



//Sustained Fire and Gun shared variables

float kickbackZ = 0;

private bool  startKickback = false;



//General Variables

private ParticleEmitter hitParticles;

int ammoPerClip = 40;

int clips = 20;

int maxClips = 20;

float reloadTime= 0.5f;

float reloadInTime= 0.5f;

float reloadOutTime= 0.5f;

Renderer muzzleFlash;

float waitforReload= 0.00f;

bool  gunActive = false;

bool  infiniteAmmo = false;

bool  reloading = false;

float ammoLeft = 0;

float nextFireTime= 0.0f;

private FIXME_VAR_TYPE m_LastFrameShot= -1;

private bool  muzzleFlashOn = false;

private GameObject mainCam;

private GameObject weaponCam;

float kickbackAngle;

bool  isPrimaryWeapon = true;

private gunscript primaryWeapon;

gunscript secondaryWeapon;

bool  secondaryActive = false;

bool  secondaryInterrupt = false;

bool  secondaryFire = false;

enum ammoTypes {byClip, byBullet}

ammoTypes ammoType = ammoTypes.byClip;

bool  shellEjection = false;

GameObject ejectorPosition;

GameObject shell;



//Variables shared between launcher and Gun

float fireRate= 0.05f;

static float crosshairSpread;

private float shotSpread;

private float actualSpread;

FIXME_VAR_TYPE standardSpread= .1;

private FIXME_VAR_TYPE spreadRate= .05;

float maxSpread= .25;

float crouchSpreadModifier= .7;

float moveSpreadModifier= 1.5f;

float standardSpreadRate= .05;

float aimSpreadRate= .01;

float aimSpread= .01;

float spDecRate= .05;

bool  autoFire;

bool  fireAnim = false;

bool  progressiveReload = false;

private bool  progressiveReloading = false;

private float pReloadTime = 0;

float delay = 0;

private bool  inDelay = false;

bool  hitBox = false;



//Ammo Sharing

bool  sharesAmmo = false;

bool  shareLoadedAmmo = false;

int ammoSetUsed = 0;

GameObject managerObject;

managerObject = GameObject.FindWithTag("Manager");





//Sway

Vector3 swayFactor;

private Vector3 walkSway1;

private Vector3 walkSway2;

private int swayTarget = 1;

float swayRate = .5;

private GameObject player;

private Vector3 startPosition;

private bool  areSprinting = false;

bool  aim = false;

aimmode aim1;



void  aiming (){

        shotSpread = aimSpread;

        spreadRate = aimSpreadRate;

        if(FPSWalkerDB.crouching)

                crouching();

        if(FPSWalkerDB.walking)

                walking();

}



void  crouching (){

        shotSpread *= crouchSpreadModifier;

        spreadRate *= crouchSpreadModifier;

}

void  walking (){

        shotSpread = Mathf.Max(standardSpread*moveSpreadModifier, shotSpread);

        spreadRate *= moveSpreadModifier;

}

void  stopWalking (){

        spreadRate = standardSpreadRate;

        if(shotSpread < standardSpread)

                shotSpread = standardSpread;

        if(GetComponentInChildren<aimmode>().aiming){

                spreadRate = aimSpreadRate;

                shotSpread = aimSpread;

        }

        if(shotSpread > maxSpread)

                shotSpread = maxSpread;



}

void  stopAiming (){

        shotSpread = standardSpread;

        spreadRate = standardSpreadRate;

        if(FPSWalkerDB.crouching){

                crouching();

        }

        if(FPSWalkerDB.walking)

                walking();

}

void  Cooldown (){

        if(FPSWalkerDB.crouching && FPSWalkerDB.walking && shotSpread > standardSpread*crouchSpreadModifier*moveSpreadModifier){

                shotSpread = Mathf.Max(standardSpread*crouchSpreadModifier*moveSpreadModifier, shotSpread - spDecRate);

        } else if(FPSWalkerDB.crouching && shotSpread > standardSpread*crouchSpreadModifier){

                shotSpread = Mathf.Max(standardSpread*crouchSpreadModifier, shotSpread - spDecRate);

        } else if(FPSWalkerDB.walking && shotSpread > standardSpread*moveSpreadModifier){

                shotSpread = Mathf.Max(standardSpread*moveSpreadModifier, shotSpread - spDecRate);

        } else if(shotSpread > standardSpread && !FPSWalkerDB.walking && !FPSWalkerDB.crouching){

                shotSpread = Mathf.Max(standardSpread, shotSpread - spDecRate);

        }

        if(laserGFX != null){

                laserGFX.active = false;

                if (audio) {

                        audio.Stop();

                }

        }



}



void  Start (){

        aim1 = GetComponentInChildren<aimmode>();

        inDelay = false;

        hitBox = false;

       

        if(sharesAmmo){

                clips = managerObject.GetComponent<AmmoManager>().clipsArray[ammoSetUsed];

                maxClips = managerObject.GetComponent<AmmoManager>().maxClipsArray[ammoSetUsed];

                infiniteAmmo = managerObject.GetComponent<AmmoManager>().infiniteArray[ammoSetUsed];

               

        }



        if(!isPrimaryWeapon){

                gunActive = false;

                FIXME_VAR_TYPE wpns= new Array();

                wpns = this.GetComponents(gunscript);

                for(int p = 0; p < wpns.length; p++){

                        if(wpns[p].isPrimaryWeapon){

                                primaryWeapon = wpns[p];

                        }

                }

        }

        if(laserGFX != null)

                laserGFX.active = false;

        hitParticles = GetComponentInChildren<ParticleEmitter>();

        shotSpread = standardSpread;

        spreadRate = standardSpreadRate;

        // We don't want to emit particles all the time, only when we hit something.

        if (hitParticles)

                hitParticles.emit = false;

        ammoLeft = ammoPerClip;

        SendMessage("updateAmmo", ammoLeft, SendMessageOptions.DontRequireReceiver);

        SendMessage("updateClips", clips, SendMessageOptions.DontRequireReceiver);

        player = GameObject.FindWithTag("Player");

        controller = player.GetComponent<Rigidbody>();

        defineSwayPoints();

        startPosition = transform.localPosition;

        muzzleFlash.enabled = false;

        mainCam = GameObject.FindWithTag("MainCamera");

        weaponCam = GameObject.FindWithTag("WeaponCamera");

}

void  Update (){

        if(progressiveReloading){

                if(ammoLeft < ammoPerClip){

                        if(Time.time > pReloadTime){

                                BroadcastMessage("ReloadAnim", reloadTime);

                                pReloadTime = Time.time + reloadTime;

                                ammoLeft++;

                                clips--;

                                SendMessage("updateAmmo", ammoLeft, SendMessageOptions.DontRequireReceiver);

                                SendMessage("updateClips", clips, SendMessageOptions.DontRequireReceiver);

                        }

                } else if(Time.time > pReloadTime) {

                        progressiveReloading = false;

                        BroadcastMessage("ReloadOut", reloadOutTime);

                        reloading=false;

                        if(aim)

                                aim1.aim = true;

                        aim1.canSwitchWeaponAim = true;

                        ApplyToSharedAmmo();

                }

        }

       

        if(actualSpread != shotSpread){

                actualSpread += (shotSpread-actualSpread)*Time.deltaTime*16;

        }

        if(gunActive){

                if(!playerweapons.autoFire && autoFire){

                        SendMessageUpwards("FullAuto");

                }

                if(playerweapons.autoFire && !autoFire){

                        SendMessageUpwards("SemiAuto");

                }

        }

}

void  LateUpdate (){

        if(shotSpread > maxSpread)

                shotSpread = maxSpread;



        if(gunActive)

                crosshairSpread = actualSpread*180/mainCam.camera.fieldOfView*Screen.height;

       

        if(!gunActive || reloading){

                if(laserGFX != null){

                        laserGFX.active = false;               

                        if (audio) {

                                audio.Stop();

                        }

                }

        }

       

        if(Input.GetKeyDown("q") && secondaryWeapon != null){

                if(!secondaryWeapon.gunActive){

                        activateSecondary();

                } else if(secondaryWeapon.gunActive){

                        activatePrimary();

                }

        }

       

        if(FPSWalkerDB.walking){

                walkSway();

        } else {

                resetPosition();

        }

               

        if (muzzleFlash && muzzleFlashOn) {

                // We shot this frame, enable the muzzle flash

                bool  scoped = transform.Find("AimObject").GetComponent<aimmode>().inScope;

                if (m_LastFrameShot == Time.frameCount) {

                        if(!scoped)

                                muzzleFlash.enabled = true;

                        if (audio) {

                                        audio.Play();

                                audio.loop = true;

                        }

                } else {

                // We didn't, disable the muzzle flash

                        muzzleFlash.enabled = false;

                        muzzleFlashOn = false;

                       

                        // Play sound

                        if (audio){

                                audio.loop = false;

                        }

                }

        }

}

void  FireAlt (){

        if(!isPrimaryWeapon){

                AlignToSharedAmmo();

                gunActive = true;

                Fire();

                gunActive = false;

        }

}

void  AlignToSharedAmmo (){

        if(sharesAmmo){

                clips = managerObject.GetComponent<AmmoManager>().clipsArray[ammoSetUsed];

                maxClips = managerObject.GetComponent<AmmoManager>().maxClipsArray[ammoSetUsed];

                infiniteAmmo = managerObject.GetComponent<AmmoManager>().infiniteArray[ammoSetUsed];

                SendMessage("updateAmmo", ammoLeft, SendMessageOptions.DontRequireReceiver);

                SendMessage("updateClips", clips, SendMessageOptions.DontRequireReceiver);     

        }



}

void  ApplyToSharedAmmo (){

        if(sharesAmmo){

                managerObject.GetComponent<AmmoManager>().clipsArray[ammoSetUsed] = clips;

                managerObject.GetComponent<AmmoManager>().maxClipsArray[ammoSetUsed] = maxClips;

                managerObject.GetComponent<AmmoManager>().infiniteArray[ammoSetUsed] = infiniteAmmo;

                }



}

void  Fire2 (){

        if(isPrimaryWeapon && secondaryWeapon != null && gunActive && secondaryWeapon.secondaryFire){

                ApplyToSharedAmmo();

                secondaryWeapon.FireAlt();



        }

}

void  Fire (){

        if (!gunActive || areSprinting || inDelay)

                return;

        if(progressiveReloading){

                progressiveReloading = false;

                reloading = false;

                if(aim)

                        aim1.aim = true;

                aim1.canSwitchWeaponAim = true;

                if(secondaryWeapon != null && secondaryWeapon.secondaryFire && !secondaryWeapon.secondaryInterrupt){

                                secondaryWeapon.reloading = false;

                        } else if(secondaryFire &&!secondaryInterrupt && !isPrimaryWeapon){

                                primaryWeapon.reloading = false;

                        }



        }



        int b = 1; //variable to control burst fire

               

        if ((ammoLeft <= 0) || ( nextFireTime > Time.time ) || !gunActive || reloading){

                if(ammoLeft <=0){

                        Reload();

                }

                return;

        }

        hitBox = true;



        if(gunType != gunTypes.sustained){

                if(burstFire){

                        b = burstCount;

                } else {

                        b = 1;

                }

                for(FIXME_VAR_TYPE i=0; i<b; i++){

                        if(ammoLeft > 0){

                                FireShot();

                                ammoLeft--;

                                if(fireRate<delay){    

                                        nextFireTime = Time.time+delay;

                                } else {

                                        nextFireTime = Time.time+fireRate;

                                }

                                if(secondaryWeapon != null && secondaryWeapon.secondaryFire && !secondaryWeapon.secondaryInterrupt){

                                        if(fireRate<delay){    

                                                secondaryWeapon.nextFireTime = Time.time+delay;

                                        } else {

                                                secondaryWeapon.nextFireTime = Time.time+fireRate;

                                        }

                                } else if(secondaryFire && !secondaryInterrupt && !isPrimaryWeapon){

                                        if(fireRate<delay){    

                                                primaryWeapon.nextFireTime = Time.time+delay;

                                        } else {

                                                primaryWeapon.nextFireTime = Time.time+fireRate;

                                        }



                                }

                                if(burstFire && i < (b-1)){

                                        if(burstTime/burstCount<delay){

                                                yield return new WaitForSeconds(delay);

                                        } else {

                                                yield return new WaitForSeconds(burstTime/burstCount);

                                        }

                                }

                        }              

                }

        } else {       

                FireLaser();

                float APS = ammoPerSecond*Time.deltaTime;

                ammoLeft -= APS;

        }      

        ApplyToSharedAmmo();

               

        SendMessage("updateAmmo", ammoLeft, SendMessageOptions.DontRequireReceiver);

        SendMessage("updateClips", clips, SendMessageOptions.DontRequireReceiver);

        if (ammoLeft <= 0){

                if(fireRate<delay){

                        yield return new WaitForSeconds(delay);

                } else {

                        yield return new WaitForSeconds(fireRate);

                }

                Reload();

       

        }



}

void  FireShot (){

        if(isPrimaryWeapon){

                if(fireAnim && !autoFire && !burstFire){

                        BroadcastMessage("singleFireAnim", fireRate);

                } else {

                        BroadcastMessage("FireAnim");

                }

        } else {

                if(fireAnim && !autoFire && !burstFire){

                        BroadcastMessage("singleSecFireAnim", fireRate);

                } else {

                        BroadcastMessage("SecondaryFireAnim");

                }

        }

        if(shellEjection && !this.GetComponentInChildren<aimmode>().inScope)

                ejectShell();

        if(gunType == gunTypes.gun || gunType == gunTypes.melee){

                inDelay = true;

                yield return new WaitForSeconds(delay);

                inDelay = false;

                for (FIXME_VAR_TYPE i=0; i<shotCount; i++) {

                        FireOneBullet();

                        Kickback();

                }

        } else if (gunType == gunTypes.launcher){

                inDelay = true;

                yield return new WaitForSeconds(delay);

                inDelay = false;

                for (FIXME_VAR_TYPE p=0; p<projectileCount; p++) {

                        FireOneProjectile();

                }

        }      

                m_LastFrameShot = Time.frameCount;

                muzzleFlashOn = true;

                if(shotSpread < maxSpread)

                        shotSpread = shotSpread + spreadRate;

                hitBox = false;

}

void  FireLaser (){

                FIXME_VAR_TYPE layerMask= 1 << 8;

                layerMask = ~layerMask;

                RaycastHit hit;

                FIXME_VAR_TYPE direction= transform.TransformDirection(Vector3(0,0,1));

               

        // Did we hit anything?

                if (Physics.Raycast (transform.position, direction, hit, laserRange, layerMask)) {

                        // Apply a force to the rigidbody we hit information

                        FIXME_VAR_TYPE hitRotation= Quaternion.FromToRotation(Vector3.up, hit.normal);

                        FIXME_VAR_TYPE hitInfo= new Array(hit.point, hitRotation, hit.transform, hit.normal);

                        if (hit.rigidbody)

                                hit.rigidbody.AddForceAtPosition(force * direction, hit.point);

               

                        // Place the particle system for spawing out of place where we hit the surface!

                        // And spawn a couple of particles

                        if (hitParticles) {

                                hitParticles.transform.position = hit.point;

                                hitParticles.transform.rotation = Quaternion.FromToRotation(Vector3.up, hit.normal);

                                hitParticles.Emit();

                        }



                        // Send a damage message to the hit object                     

                        hit.collider.SendMessageUpwards("ApplyDamage", damagePerSecond*Time.deltaTime, SendMessageOptions.DontRequireReceiver);

                        hit.collider.SendMessageUpwards("accuracy", SendMessageOptions.DontRequireReceiver);

                        //And send a message to the DecalManager

                        hit.collider.SendMessageUpwards("ApplyLaserDecal", hitInfo, SendMessageOptions.DontRequireReceiver);

                }

                if(laserGFX != null){

                        laserGFX.active = true;

                        laserGFX.GetComponent<LineRenderer>().enabled = true;

                        if (audio && !audio.isPlaying) {

                                audio.loop = true;

                                audio.Play();

                        }

                        FIXME_VAR_TYPE laserPoint= Vector3(0,0, Mathf.Abs(Vector3.Distance(laserGFX.transform.position , hit.point) + 1));

                        laserGFX.GetComponent<LineRenderer>().SetPosition(1 , laserPoint);

                }

                        Kickback();

}

       

void  FireOneProjectile (){

        //if(isPrimaryWeapon){

        //      BroadcastMessage("FireAnim");

        //} else {

        //      BroadcastMessage("SecondaryFireAnim");



        //}



        FIXME_VAR_TYPE direction= SprayDirection();



        if(launchPosition != null){

                Rigidbody instantiatedProjectile1 = Instantiate (projectile, launchPosition.transform.position, mainCam.transform.rotation);

        } else {

                Rigidbody instantiatedProjectile = Instantiate (projectile, transform.position, mainCam.transform.rotation);

        }

       

        if(launchPosition != null){

                instantiatedProjectile1.velocity = transform.TransformDirection(Vector3 (0, 0, initialSpeed));

                Physics.IgnoreCollision(instantiatedProjectile1.collider, transform.root.collider);

                Physics.IgnoreCollision(instantiatedProjectile1.collider, gameObject.FindWithTag("Player").transform.root.collider);



        } else {

                instantiatedProjectile.velocity = transform.TransformDirection(Vector3 (0, 0, initialSpeed));

                Physics.IgnoreCollision(instantiatedProjectile.collider, transform.root.collider);

                Physics.IgnoreCollision(instantiatedProjectile.collider, gameObject.FindWithTag("Player").transform.collider);



        }



        Kickback();

}



void  FireOneBullet (){  

        bool  penetrate = true;

        int pVal = penetrateVal;

        FIXME_VAR_TYPE layerMask= 1<<8 + 1<<2;

        layerMask = ~layerMask;

        RaycastHit[] hits;

        FIXME_VAR_TYPE direction= SprayDirection();

        hits = Physics.RaycastAll (transform.position, direction, range, layerMask);

        System.Array.Sort(hits, Comparison);   

//       Did we hit anything?

        for (FIXME_VAR_TYPE i=0;i<hits.length;i++){

        RaycastHit hit = hits[i];

        BulletPenetration BP = hit.transform.GetComponent<"BulletPenetration">();

        if(penetrate){

                if(BP == null){

                        penetrate = false;

                } else {

                        if(pVal < BP.penetrateValue){

                                penetrate = false;

                        } else {

                                pVal -= BP.penetrateValue;

                        }      

                }

                        //The DecalManager needs two bits of information

                        FIXME_VAR_TYPE hitRotation= Quaternion.FromToRotation(Vector3.up, hit.normal);

                        FIXME_VAR_TYPE hitInfo= new Array(hit.point, hitRotation, hit.transform, hit.normal);

                        // Apply a force to the rigidbody we hit

                        if (hit.rigidbody)

                                hit.rigidbody.AddForceAtPosition(force * direction, hit.point);

               

                        // Place the particle system for spawing out of place where we hit the surface!

                        // And spawn a couple of particles

                        if (hitParticles) {

                                hitParticles.transform.position = hit.point;

                                hitParticles.transform.rotation = Quaternion.FromToRotation(Vector3.up, hit.normal);

                                hitParticles.Emit();

                        }

               



//                      // Send a damage message to the hit object                     

                        hit.collider.SendMessageUpwards("ApplyDamage", damage, SendMessageOptions.DontRequireReceiver);

                        hit.collider.SendMessageUpwards("accuracy", SendMessageOptions.DontRequireReceiver);

                        //And send a message to the decal manager

                        hit.collider.SendMessageUpwards("ApplyDecal", hitInfo, SendMessageOptions.DontRequireReceiver);



                }

        }



}

int Comparison ( RaycastHit x ,   RaycastHit y  ){

   FIXME_VAR_TYPE xDistance= x.distance;

   FIXME_VAR_TYPE yDistance= y.distance;

   return xDistance - yDistance;

}

void  SprayDirection (){

        FIXME_VAR_TYPE vx= (1 - 2 * Random.value) * actualSpread;

        FIXME_VAR_TYPE vy= (1 - 2 * Random.value) * actualSpread;

        FIXME_VAR_TYPE vz= 1.0f;

        return mainCam.transform.TransformDirection(Vector3(vx,vy,vz));



}

void  Reload (){

        if(ammoLeft >= ammoPerClip || clips <= 0 || !gunActive){

                return;

        }

        if(progressiveReload){

                ProgReload();

                return;

        }

        if(!reloading){

                //if ((ammoType == ammoTypes.byClip && ammoLeft < ammoPerClip && clips > 0 && gunActive) || (ammoType == ammoTypes.byBullet && ammoLeft < ammoPerClip && clips > 0 && gunActive)){

                        aim1.canSwitchWeaponAim = false;

                        if(aim1.aim){

                                aim1.aim = false;

                                aim = true;

                                }

                        reloading=true;

                        if(secondaryWeapon != null){

                                secondaryWeapon.reloading = true;

                        } else if(!isPrimaryWeapon){

                                primaryWeapon.reloading = true;

                        }

                        yield return new WaitForSeconds(waitforReload);

                                        if(isPrimaryWeapon){

                                                BroadcastMessage("ReloadAnim", reloadTime);

                                        } else {

                                                BroadcastMessage("SecondaryReloadAnim", reloadTime);

                                        }      



                // Wait for reload time first - then add more bullets!

                yield return new WaitForSeconds(reloadTime);

                reloading = false;

                if(secondaryWeapon != null){

                        secondaryWeapon.reloading = false;

                } else if(!isPrimaryWeapon){

                        primaryWeapon.reloading = false;

                }

                // We have a clip left reload

                if(ammoType == ammoTypes.byClip){

                        if (clips > 0) {

                                if(!infiniteAmmo)

                                        clips--;

                                ammoLeft = ammoPerClip;

                        }

                } else if (ammoType == ammoTypes.byBullet){

                        if(clips > 0){

                                        if(clips > ammoPerClip){

                                                clips -= ammoPerClip - ammoLeft;

                                                ammoLeft = ammoPerClip;

                                        } else {

                                                ammoVal = Mathf.Clamp(ammoPerClip, clips, ammoLeft+clips);

                                                clips -= (ammoVal - ammoLeft);

                                                ammoLeft = ammoVal;

                                        }

                                }      

                        }

                if(aim)

                        aim1.aim = true;

                aim1.canSwitchWeaponAim = true;

                SendMessage("updateAmmo", ammoLeft, SendMessageOptions.DontRequireReceiver);

                SendMessage("updateClips", clips, SendMessageOptions.DontRequireReceiver);

                //}

                ApplyToSharedAmmo();



        }

}

void  ProgReload (){

        if(reloading)

                return;

        aim1.canSwitchWeaponAim = false;

        if(aim1.aim){

                aim1.aim = false;

                aim = true;

        }



        BroadcastMessage("ReloadIn", reloadInTime);

        yield return new WaitForSeconds(reloadInTime);

        progressiveReloading = true;

        reloading=true;

        if(secondaryWeapon != null && secondaryWeapon.secondaryFire && !secondaryWeapon.secondaryInterrupt){

                secondaryWeapon.reloading = true;

        } else if(secondaryFire && !secondaryInterrupt && !isPrimaryWeapon){

                primaryWeapon.reloading = false;

        }

       

}

void  GetBulletsLeft (){

        return ammoLeft;

}

void  selectWeapon (){ 

        AlignToSharedAmmo();



        aimmode aim1 = GetComponentInChildren<aimmode>();

       

        if(!isPrimaryWeapon)

                        return;

                       

        FIXME_VAR_TYPE gos= GetComponentsInChildren<Renderer>();

        foreach( Renderer go in gos){

                if (go.name != "muzzle_flash")

                go.enabled=true;

        }

        if(secondaryWeapon != null){

                secondaryWeapon.gunActive = false;

                secondaryWeapon.secondaryActive = false;

                BroadcastMessage("aimPrimary", SendMessageOptions.DontRequireReceiver);

        }

        if(!takingOut && !gunActive){

                aim1.canSwitchWeaponAim = false;

                BroadcastMessage("TakeOutAnim");

                takingOut = true;

        //      gunActive=false;

                yield return new WaitForSeconds(.6);

                gunActive=true;

                takingOut = false;

                aim1.canSwitchWeaponAim = true;

        }





}

void  deselectWeapon (){

        gunActive=false;

        FIXME_VAR_TYPE gos= GetComponentsInChildren<Renderer>();

        foreach( Renderer go in gos){

                go.enabled=false;



        }



}void  walkSway (){

                if(swayTarget == 1){   

                         if (Vector3.Distance(transform.localPosition, walkSway1) >= .01){

                                curVect= walkSway1 - transform.localPosition;

                                transform.Translate(curVect*Time.deltaTime*swayRate*player.GetComponent<"FPSWalkerDB">().speed,Space.Self);

                        } else {

                                swayTarget = 2;

                        }

                } else if(swayTarget == 2) {

                        if (Vector3.Distance(transform.localPosition, walkSway2) >= .01){

                                curVect= walkSway2 - transform.localPosition;

                                transform.Translate(curVect*Time.deltaTime*swayRate*player.GetComponent<"FPSWalkerDB">().speed,Space.Self);

                        } else {

                                swayTarget = 1;

                        }

                }

}



void  defineSwayPoints (){

        walkSway1 = transform.localPosition + swayFactor;

        walkSway2 = transform.localPosition - swayFactor;

}



void  resetPosition (){

                 if (transform.localPosition != startPosition){

                        curVect= startPosition - transform.localPosition;

                        transform.Translate(curVect*Time.deltaTime*2,Space.Self);

                 }

}



void  sprinting (){

        areSprinting = true;

}

void  normalSpeed (){

        areSprinting = false;

        if(secondaryWeapon != null){

                if(isPrimaryWeapon && secondaryWeapon.secondaryActive)

                        return;

        }

        if(!isPrimaryWeapon && !secondaryActive)

                return;



        gunActive = true;

}

void  Kickback (){

        mainCam.GetComponent<"MouseLook">().offsetY = kickbackAngle;

        weaponCam.GetComponent<"MouseLook">().offsetY = kickbackAngle;

}



void  KickbackZ (){

        startKickback = true;

        walkSway1 = Vector3( walkSway1.x, walkSway1.y, (walkSway1.z - kickbackZ));

        walkSway2 = Vector3( walkSway2.x, walkSway2.y, (walkSway2.z - kickbackZ));

        startPosition = Vector3( startPosition.x, startPosition.y, (startPosition.z - kickbackZ));



}



void  ceaseFiring (){

        walkSway1 = Vector3( walkSway1.x, walkSway1.y, (walkSway1.z + kickbackZ));

        walkSway2 = Vector3( walkSway2.x, walkSway2.y, (walkSway2.z + kickbackZ));

        startPosition = Vector3( startPosition.x, startPosition.y, (startPosition.z + kickbackZ));

        startKickback = false;

}

void  activateSecondary (){

        if(secondaryWeapon == null || secondaryWeapon.secondaryFire)

                return;

        AlignToSharedAmmo();

       

        if(gunActive){

                gunActive = false;

                secondaryWeapon.gunActive = true;

                secondaryWeapon.secondaryActive = true;

                SendMessage("updateAmmo", secondaryWeapon.ammoLeft, SendMessageOptions.DontRequireReceiver);

                SendMessage("updateClips", secondaryWeapon.clips, SendMessageOptions.DontRequireReceiver);

                BroadcastMessage("aimSecondary", SendMessageOptions.DontRequireReceiver);



        }

}

void  activatePrimary (){

        AlignToSharedAmmo();

        if(!gunActive){

                gunActive = true;

                secondaryWeapon.gunActive = false;

                secondaryWeapon.secondaryActive = false;

                SendMessage("updateAmmo", ammoLeft, SendMessageOptions.DontRequireReceiver);

                SendMessage("updateClips", clips, SendMessageOptions.DontRequireReceiver);

                BroadcastMessage("aimPrimary", SendMessageOptions.DontRequireReceiver);



        }

}

void  ejectShell (){

                FIXME_VAR_TYPE instantiatedProjectile1= Instantiate (shell, ejectorPosition.transform.position, ejectorPosition.transform.rotation);

                instantiatedProjectile1.transform.parent = ejectorPosition.transform;



}

}

Вот ошибки :

[GrayFiend]

Unexpected symbol '=' потому что инициалиацию вида

float initialSpeed= 20.0f;
int projectileCount = 1;

и т.д. делать можно только для целочисленных статик-констант. Остальноё всё переноси в конструктор и прочие методы, оставляя в теле только объявление.

[waruiyume]

<<...делать можно только для целочисленных статик-констант.>>- неужели?

По сабж:

Синтаксис:

Синтаксис: [ Показать ]

Используется csharp

GameObject managerObject;
managerObject = GameObject.FindWithTag("Manager");//- в теле класса этого делать нельзя

//можно так, но из-за особенностей Unity работать не будет, т.к. "FindWithTag" нельзя вызывать из конструктора.
GameObject managerObject = GameObject.FindWithTag("Manager");
//присвоение можно произвести в методах "Start" или "Awake"
//------------------------------------------
//во всех подобных случаях
float maxSpread= .25;
//нужно дописать f после цифр
float maxSpread= .25f;//- без f тип будет- double, с f- float
//------------------------------------------
//во всех подобных случаях нужно убрать кавычки
BulletPenetration BP = hit.transform.GetComponent<"BulletPenetration">();
//без кавычек
BulletPenetration BP = hit.transform.GetComponent<BulletPenetration>();
//------------------------------------------
//нужно изменить тип возвращаемого на  "IEnumerator"
void  Fire (){
//
IEnumerator Fire (){
//а внутри метода дописать yield перед return
yield return;

 

[GrayFiend]

<<...делать можно только для целочисленных статик-констант.>>- неужели?

По сишному стандарту так. Но похоже у свои взгляды на это дело

[waruiyume]

Угу, на Ассемблере, это вообще не имеет смысла. В Unity3D C#, не С, не С++, а Си Шарп (Кэп).