// Start is called before the first frame update
void Start()
{
this.anim = GetComponent <Animator>();
arm = FindObjectOfType <arm>();
active = true;
this.tform = GetComponent <Transform>();
}
/// <summary>
/// Allows the game component to perform any initialization it needs to before starting
/// to run. This is where it can query for any required services and load content.
/// </summary>
public override void Initialize()
{
this.frame = 0;
_Xvelocity = 0;
_Yvelocity = 0;
jumping = true;
kicking = false;
playerArm = new arm(_game, _playgame, "armsheet", vector.X, vector.Y);
base.Initialize();
}
//remember for cylinder, width (y - scale) is half of real
public void Init(Vector3 position, float angle)
{
//следующее звено
FixedJoint fixedjoint = GetComponent <FixedJoint>();
GameObject next = fixedjoint.connectedBody.gameObject;
arm nextbehavior = fixedjoint.connectedBody.GetComponent <arm>();
//размещаем следующее звено
next.transform.localScale = new Vector3(nextbehavior.width, nextbehavior.length, nextbehavior.width);
next.transform.position = new Vector3(transform.position.x, transform.position.y + (diameter + nextbehavior.length) / 2, transform.position.z);
//якорь шарнира
fixedjoint.anchor = new Vector3(0.0f, 0.5f, 0.0f);
//инициализируем следующие звенья
nextbehavior.Init(position, angle);
//поворачиваем вокруг вертикальной оси
transform.RotateAround(position, Vector3.down, angle);
}
public bool CheckStaticFrames (ref arm theArm)
{
int frames_cap1 = 15;
int frames_cap2 = 30;
int frames_cap3 = 45;
//Depending on the number of frames
//A 0-15 change color to white
if(theArm.handOnCooldown){
theArm.rayColor = Color.yellow;
theArm.frameCount = 0;
}
else if (theArm.deactivated){
theArm.rayColor = Color.yellow;
theArm.frameCount = 0;
}
else
{
if (theArm.frameCount < frames_cap1)
{
theArm.rayColor = Color.white;
return false;
}
//B 15-30 change color to blue
else if (theArm.frameCount > frames_cap1 && theArm.frameCount < frames_cap2)
{
theArm.rayColor = Color.blue;
}
//C +30 change color to red and ready to deploy
else if (theArm.frameCount > frames_cap2)
{
theArm.rayColor = Color.green;
return true; // IF we reach this point there is no need to keep checking this
}
}
return false;
}
/*
ExpandObject
*/
void ExpandObject(arm theArm, Vector3 direction)
{
float scalingDuration = 0.3f;
Vector3 newScale = new Vector3(rightArm.Prefab.transform.localScale.x + direction.x * 5, rightArm.Prefab.transform.localScale.y, rightArm.Prefab.transform.localScale.z);
float scaleStep = Time.deltaTime / scalingDuration;
rightArm.Prefab.transform.localScale = Vector3.Lerp(transform.localScale, newScale, scaleStep);
}
/*
checkIfActive: the input arm is occupied
*/
void checkIfActive(ref arm theArm)
{
if (!theArm.runningPositionLocation)
{
print(theArm.runningPositionLocation);
print("Starting Courutine with: "+ theArm.ObjHand.name+ "\n");
StartCoroutine( FixedPointer(theArm));
}
else
{
print("A courutine was running already for: " + theArm.ObjHand.name + "So ignore\n");
}
}
/*
DismissAction
*/
void DismissAction (arm theArm)
{
}
/*
UpdateRayPointer. Find if we should cast a ray
*/
Vector3 UpdateRayPointer(ref arm theArm)
{
Vector3 RayColission = new Vector3(0,0,0);
RaycastHit hit;
theArm.pointer = RayColission;
//Color rayColor = RayColor;
Vector3 Ref1 = theArm.ObjHand.transform.position;
Vector3 Ref2 = theArm.ObjElvow.transform.position;
Vector3 Ref3 = theArm.ObjShoulder.transform.position;
Vector3 Direction = JointRelativePosition(Ref2, Ref1, false);
Ray theRay = new Ray(Ref1, Direction);
Physics.Raycast(theRay, out hit, 100);
theArm.ObjectHit = hit.transform.gameObject;
theArm.pointer = hit.point;
Debug.DrawLine(Ref1, hit.point, theArm.rayColor);
return hit.point;
}
/*
This will run in the background
If succedded it will start a cooldown
*/
public IEnumerator FixedPointer(arm TheArm)
{
TheArm.runningPositionLocation = true;
float smallDistance = 2f;
float LargeDistance = 4f;
Vector3 OPoint = TheArm.pointer;
Vector3 thePoint;
bool isDone = false;
bool check = false;
print("First Position of " + TheArm.ObjHand.name + " is" + OPoint);
//StartCoroutine(Wait(3f, TheArm));
print("Waiting for" + 3f + "seconds....... TIME ="+ Time.time);
yield return new WaitForSeconds(3f);
print("End Waiting for" + 3f + "seconds....... TIME =" + Time.time);
// get the point
thePoint = TheArm.pointer;
print("Second Position of " + TheArm.ObjHand.name + " is" + thePoint);
check = checkRayOnPoint(smallDistance, thePoint, OPoint);
if (check)
{
print(smallDistance + "distance is "+ check);
TheArm.rayColor = Color.blue;
float distance = Vector3.Distance(thePoint, OPoint);
/*
StartCoroutine(Wait(0.3f));
// get the point
print("runing second part of the courutine");
thePoint = TheArm.pointer;
if (checkRayOnPoint(smallDistance, thePoint, OPoint))
{
print(smallDistance + "distance");
RayColor = Color.blue;
distance = Vector3.Distance(thePoint, OPoint);
}
*/
}
else
{
print("Aborting wait, at time = " + Time.time);
TheArm.rayColor = Color.white;
TheArm.runningPositionLocation = false;
}
/*
UpdateRayPointer(TheArm);
thePoint = TheArm.pointer;
check = checkRayOnPoint(smallDistance, OPoint, thePoint);
if (check)
{
}
else
isDone = true;
*/
TheArm.runningPositionLocation = true;
// Get where the raycast hits thePoint =
//This is a coroutine
//isStopped = false;
//Vector3 velocityBall = gameController.StartKick(gameController.BallSpeed, direction);
//GetComponent<Rigidbody>().velocity = velocityBall;
}
public IEnumerator WaitNDestroy(float waitTime, arm TheArm)
{
TheArm.handOnCooldown = true;
print("Start Waiting for" + waitTime + "seconds");
yield return new WaitForSeconds(waitTime);
print("End Waiting for" + waitTime + "seconds");
Destroy(TheArm.Prefab);
TheArm.handOnCooldown = false;
}
/// <summary>
/// Allows the game component to update itself.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
public override void Update(GameTime gameTime)
{
//First, it runs the draw logic and the timer logic of the AnimatedGameObject class (see AnimatedGameObject.cs)
base.Update(gameTime);
//on every update, it draws a new hitbox, as it extends a bit in front of the character to determine future collision.
hitbox = new Rectangle(((int)(this.vector.X + ((this.spriteWidth / 2) - 15)) + _Xvelocity), ((int)this.vector.Y + _Yvelocity), 30, this.spriteHeight);
//it also gets a list of all the ground objects Rimbo can land on. This includes destructible objects he can land on.
//This needs to happen every update, as the state of these destructible objects can change.
map = new List <ground>(_game.Components.OfType <ground>());
//Adjusting the basic movement based on the character's velocity, as well as locking him to the screen.
this.vector.X += _Xvelocity;
this.vector.Y += _Yvelocity;
this.vector.X = MathHelper.Clamp(this.vector.X, 0, (_game.GraphicsDevice.Viewport.Width - 72));
this.vector.Y = MathHelper.Clamp(this.vector.Y, 0, (_game.GraphicsDevice.Viewport.Height));
//Gravity. Rimbo can fall no faster than 15 pixels per frame, but speeds up until he does.
if (_Yvelocity < 15)
{
_Yvelocity++;
}
else
{
_Yvelocity = 15;
}
//All ground or obstacle objects are checked, to adjust Rimbo's velocity as required; he hits something, he stops.
foreach (ground Q in map)
{
if (this.hitbox.Intersects(Q.wallboxleft))
{
_Xvelocity = 0;
this.vector.X = (Q.vector.X - 50);
}
if (this.hitbox.Intersects(Q.wallboxright))
{
_Xvelocity = 0;
this.vector.X = (Q.vector.X + Q.spriteWidth) - 22;
}
if (this.hitbox.Intersects(Q.groundbox))
{
jumping = false;
_Yvelocity = 0;
this.vector.Y = (Q.vector.Y - 72);
}
}
//Determines how to draw the Sprite based on which way Rimbo is facing.
if (right)
{
this.spriteMirror = SpriteEffects.None;
playerArm.spriteMirror = SpriteEffects.None;
playerArm.vector.Y = this.vector.Y + 25;
playerArm.vector.X = this.vector.X + 27;
playerArm.origin = new Vector2(5, 9);
playerArm.spriteRotation = 0 + mousePosition();
}
else if (!right)
{
this.spriteMirror = SpriteEffects.FlipHorizontally;
playerArm.spriteMirror = SpriteEffects.FlipHorizontally;
playerArm.vector.Y = this.vector.Y + 25;
playerArm.vector.X = this.vector.X + 42;
playerArm.origin = new Vector2(57, 9);
playerArm.spriteRotation = 0 - mousePosition();
}
//Input handling.
KeyboardState keystate = Keyboard.GetState();
if (keystate.IsKeyDown(Keys.Space) && !jumping || keystate.IsKeyDown(Keys.RightShift) && !jumping)
{
//Set Rimbo to his jumping animation, give him an upward velocity and lock controls by setting jumping to true.
this.frame = 5;
_Yvelocity = -15;
jumping = true;
}
if (keystate.IsKeyDown(Keys.Right) || keystate.IsKeyDown(Keys.D))
{
//make Rimbo face right.
right = true;
//Speed Rimbo up until he hits a certain speed.
if (_Xvelocity <= 3)
{
_Xvelocity += 1;
}
else
{
_Xvelocity = 3;
}
//move Rimbo's frame up every time the animation timer depletes.
if (this.animationTimer == 0 && !jumping)
{
this.frame++;
//unless he hit the ending of this animation, then return to the first frame.
if (this.frame > 4)
{
frame = 1;
}
}
}
else if (keystate.IsKeyDown(Keys.Left) || keystate.IsKeyDown(Keys.A))
{
//make rimbo face left, same as above.
right = false;
if (_Xvelocity >= -3)
{
_Xvelocity -= 1;
}
else
{
_Xvelocity = -3;
}
if (this.animationTimer == 0 && !jumping)
{
this.frame++;
if (this.frame > 4)
{
frame = 1;
}
}
}
if (keystate.IsKeyDown(Keys.Down) || keystate.IsKeyDown(Keys.S))
{
//Display Rimbo's ducking animation.
_Xvelocity = 0;
this.frame = 6;
//Adjust the arm object accoardingly.
playerArm.vector.Y += 10;
if (right)
{
playerArm.vector.X += 5;
}
else if (!right)
{
playerArm.vector.X -= 5;
}
}
if (keystate.IsKeyDown(Keys.LeftControl) && !kicking || keystate.IsKeyDown(Keys.RightControl) && !kicking)
{
//make Rimbo kick
kicking = true;
}
if (kicking)
{
//When kicking, Rimbo comes to a halt,
_Xvelocity = 0;
if (this.animationTimer == 0)
{
//Adjust his animation.
this.frame++;
if (this.frame < 7)
{
this.frame = 7;
}
if (this.frame > 9)
{
//disable the kicking animation and go back to idle after the animation is finished.
kicking = false;
this.frame = 0;
}
}
}
//The idle state.
if (keystate.IsKeyUp(Keys.Space) && keystate.IsKeyUp(Keys.RightShift) && keystate.IsKeyUp(Keys.Right) && keystate.IsKeyUp(Keys.D) && keystate.IsKeyUp(Keys.Left) && keystate.IsKeyUp(Keys.A) && keystate.IsKeyUp(Keys.S) && keystate.IsKeyUp(Keys.Down) && keystate.IsKeyUp(Keys.RightControl) && keystate.IsKeyUp(Keys.LeftControl) && !kicking)
{
_Xvelocity = 0;
this.frame = 0;
}
//This logic checks which item the player is currently holding.
switch (_playgame.inventory.current)
{
case "none":
{
if (playerArm is Pistol || playerArm is P90 || playerArm is G36C || playerArm is MINIMI || playerArm is L96)
{
if (_game.Components.Contains(playerArm))
{
_game.Components.Remove(playerArm);
}
//It then replaces the Arm with the arm of that type.
playerArm = new arm(_game, _playgame, "armsheet", vector.X, vector.Y);
_game.Components.Add(playerArm);
}
break;
}
case "pistol":
{
if (!(playerArm is Pistol))
{
if (_game.Components.Contains(playerArm))
{
_game.Components.Remove(playerArm);
}
playerArm = new Pistol(_game, _playgame, vector.X, vector.Y);
_game.Components.Add(playerArm);
}
break;
}
case "SMG":
{
if (!(playerArm is P90))
{
if (_game.Components.Contains(playerArm))
{
_game.Components.Remove(playerArm);
}
playerArm = new P90(_game, _playgame, vector.X, vector.Y);
_game.Components.Add(playerArm);
}
break;
}
case "Rifle":
{
if (!(playerArm is G36C))
{
if (_game.Components.Contains(playerArm))
{
_game.Components.Remove(playerArm);
}
playerArm = new G36C(_game, _playgame, vector.X, vector.Y);
_game.Components.Add(playerArm);
}
break;
}
case "Machine":
{
if (!(playerArm is MINIMI))
{
if (_game.Components.Contains(playerArm))
{
_game.Components.Remove(playerArm);
}
playerArm = new MINIMI(_game, _playgame, vector.X, vector.Y);
_game.Components.Add(playerArm);
}
break;
}
case "Sniper":
{
if (!(playerArm is L96))
{
if (_game.Components.Contains(playerArm))
{
_game.Components.Remove(playerArm);
}
playerArm = new L96(_game, _playgame, vector.X, vector.Y);
_game.Components.Add(playerArm);
}
break;
}
}
}
public SimpleItemObject(arm instance)
{
_internal = instance;
}
The execution architecture (arm, amd64, etc.)
