IEnumerator generateCopies() { int randPlace; Vector3 newPos; //Pour chaque clone à créer : for (int i = 1; i <= nbClones; i++) { //On choisit une place parmi ceux libres. randPlace = Random.Range(0, remaining - 1); ORIENTATION o = setNeighbor(randPlace); newPos = getPositionNewCopy(o); GameObject g = GameObject.Instantiate(gameObject, newPos, gameObject.transform.rotation); g.SetActive(false); g.name = g.tag + "-" + generationsLeft + "-" + i; Destroy(g.GetComponent <MG_Life_Cube>()); foreach (Transform child in g.transform) { Destroy(child.gameObject); } neighbors[(int)o] = g; remaining--; g.GetComponent <MG_Life_Clone>().setInitialNeighbor(gameObject, o); g.GetComponent <MG_Life_Clone>().setGenLeft(generationsLeft - 1); g.hideFlags = HideFlags.HideInHierarchy; g.SetActive(true); yield return(new WaitForSeconds(0.25f)); } System.Array.Clear(neighbors, 0, neighbors.Length); }
void Roll(ORIENTATION face) { switch (face) { case ORIENTATION.SIDEWAYS_LEFT: rbody.AddRelativeTorque(new Vector3(0, 0, rollForce), ForceMode.Acceleration); break; case ORIENTATION.SIDEWAYS_RIGHT: rbody.AddRelativeTorque(new Vector3(0, 0, -rollForce), ForceMode.Acceleration); break; case ORIENTATION.UPSIDE_DOWN: rbody.AddRelativeTorque(new Vector3(2.0f * rollForce, 0, 0), ForceMode.Acceleration); break; case ORIENTATION.FACE_DOWN: rbody.AddRelativeTorque(new Vector3(-rollForce, 0, 0), ForceMode.Acceleration); break; case ORIENTATION.ON_BACK: rbody.AddRelativeTorque(new Vector3(rollForce, 0, 0), ForceMode.Acceleration); break; } }
//Retourne la position de la future copie à créer, selon l'orientation passée en paramètre, //de telle sorte qu'elle se trouve "collée" à la face de l'objet courant correspondant. //(Exemple : ORIENTATION.UP -> Sur la face supérieure de l'objet courant) private Vector3 getPositionNewCopy(ORIENTATION o) { Vector3 res = gameObject.transform.position, dim = gameObject.transform.lossyScale; switch (o) { case ORIENTATION.UP: res = new Vector3(res.x, res.y + dim.y, res.z); break; case ORIENTATION.DOWN: res = new Vector3(res.x, res.y - dim.y, res.z); break; case ORIENTATION.LEFT: res = new Vector3(res.x - dim.x, res.y, res.z); break; case ORIENTATION.RIGHT: res = new Vector3(res.x + dim.x, res.y, res.z); break; case ORIENTATION.FORWARD: res = new Vector3(res.x, res.y, res.z + dim.z); break; case ORIENTATION.BACKWARD: res = new Vector3(res.x, res.y, res.z - dim.z); break; } return(res); }
// Transform an angle into ORIENTATION public static ORIENTATION AngleToOrientation(float angle, ORIENTATION origin = ORIENTATION.NORTH) { int roundAngle = (int)Mathf.Round(angle / 90.0f); switch (origin) { case ORIENTATION.NORTH: roundAngle += 0; break; case ORIENTATION.EAST: roundAngle += 1; break; case ORIENTATION.SOUTH: roundAngle += 2; break; case ORIENTATION.WEST: roundAngle += 3; break; } roundAngle = roundAngle % 4; if (roundAngle < 0) { roundAngle += 4; } switch (roundAngle) { case 0: return(ORIENTATION.NORTH); case 1: return(ORIENTATION.EAST); case 2: return(ORIENTATION.SOUTH); case 3: return(ORIENTATION.WEST); default: return(ORIENTATION.NONE); } }
private Sprite CreateSprite(ORIENTATION orientation) { string texturePath = "./assets/img/agent-"; switch (orientation) { case Agent.ORIENTATION.North: texturePath += "north"; break; case Agent.ORIENTATION.East: texturePath += "east"; break; case Agent.ORIENTATION.South: texturePath += "south"; break; case Agent.ORIENTATION.West: texturePath += "west"; break; } texturePath += ".png"; Texture texture = new Texture(texturePath); return(new Sprite(texture) { Scale = new Vector2f((float)Config.FIELD_SIZE / (float)texture.Size.X, (float)Config.FIELD_SIZE / (float)texture.Size.Y) }); }
//Place le père de l'objet courant à sa bonne place dans le tableau //neighbors selon sa position par rapport à son fils. public void setInitialNeighbor(GameObject g, ORIENTATION o) { ORIENTATION n = toClonePerspective(o); neighbors[(int)n] = g; remaining--; }
public void ChangeOrientation(ORIENTATION _orientation, ALIGN _align) { m_orientation = _orientation; m_align = _align; m_gaugeTransform.localPosition = m_initPos; ComputeEdge(); }
//Retourne la position du père de l'objet courant par rapport à ce dernier. private ORIENTATION toClonePerspective(ORIENTATION o) { ORIENTATION res = ORIENTATION.UP; switch (o) { case ORIENTATION.UP: res = ORIENTATION.DOWN; break; case ORIENTATION.DOWN: res = ORIENTATION.UP; break; case ORIENTATION.LEFT: res = ORIENTATION.RIGHT; break; case ORIENTATION.RIGHT: res = ORIENTATION.LEFT; break; case ORIENTATION.FORWARD: res = ORIENTATION.BACKWARD; break; case ORIENTATION.BACKWARD: res = ORIENTATION.FORWARD; break; } return(res); }
IEnumerator MoveNextStage(ORIENTATION orientation) { yield return(new WaitForFixedUpdate()); //Define a posiçao no centro da proxima tela e move a camera Vector3 newPos = new Vector3(this.camera.transform.position.x, (this.WorldPos.y * this.currentStageY) + (this.WorldPos.y * (int)orientation), this.camera.transform.position.z); this.camera.transform.position = Vector3.MoveTowards(this.camera.transform.position, newPos, this.speedCamera * Time.deltaTime); //Confere a distancia para parar o movimento da camera. float currentDistance = Vector3.Distance(this.camera.transform.position, newPos); if (currentDistance > this.totalDistance / 100) { StartCoroutine(MoveNextStage(orientation)); } else { this.cameraMoving = false; this.ResetWorldPos(); this.currentStageY += (int)orientation; print(this.currentStageY); // StopCoroutine(this.MoveNextStage(direction)); } }
private void GenerateDungeon() { // Main path generation int mainPathLength = Random.Range(minMainPathLength, maxMainPathLength + 1); Vector3 buildingPosition = new Vector2(0, 0); ORIENTATION buildingDirection = ORIENTATION.NONE; Node firstNode = new Node(buildingPosition, 0, false); // Add to nodes list nodes.Add(firstNode); // Add to dictionary of paths if (!paths.ContainsKey(0)) { paths.Add(0, new List <Node>()); } paths[0].Add(firstNode); bool success = GeneratePath(0, mainPathLength, buildingPosition, buildingDirection); if (!success) { Debug.LogError("Main path failed. Everything stopped"); } // Secondary paths generation int secondaryPathsCount = 0; int progressionIndex = Random.Range(minRoomsBeforeNewSecondary, maxRoomsBeforeNewSecondary); while (progressionIndex < paths[0].Count) { List <ORIENTATION> availableOrientations = paths[0][progressionIndex].GetAvailableOrientations(); if (availableOrientations.Count == 0) { progressionIndex++; continue; } int secondaryPathLength = Random.Range(minSecondaryPathLength, maxSecondaryPathLength + 1); buildingPosition = paths[0][progressionIndex].position; buildingDirection = availableOrientations[Random.Range(0, availableOrientations.Count)]; success = GeneratePath(secondaryPathsCount + 1, secondaryPathLength, buildingPosition, buildingDirection); if (success) { progressionIndex += Random.Range(minRoomsBeforeNewSecondary, maxRoomsBeforeNewSecondary); } else { progressionIndex++; } } }
// Can only generate linear paths possibly connected to a parent path private bool GeneratePath(int pathID, int pathLength, Vector2 startPos, ORIENTATION startDir) { int pathToBuildRemaining = pathLength; Vector2 currentPos = startPos; ORIENTATION currentDir = startDir; // This can be null Node buildFromNode = nodes.FirstOrDefault(x => x.position == currentPos); // Returned int is the amount of rooms we wont be able to place anyway Tuple <PossibleBuild, int> tuple = GetPossibleBuild(pathToBuildRemaining, currentDir, currentPos, buildFromNode?.GetOrientationsWithoutDoors()); if (tuple.Item2 > 0) { if (failIfPossiblePathTooShort) { return(false); } else { // Remove amount of rooms we wont be able to build pathToBuildRemaining -= tuple.Item2; } } while (pathToBuildRemaining > 0) { pathToBuildRemaining--; buildFromNode = nodes.FirstOrDefault(x => x.position == currentPos); // Returned int is the amount of rooms we wont be able to place anyway tuple = GetPossibleBuild(pathToBuildRemaining, currentDir, currentPos, buildFromNode?.GetOrientationsWithoutDoors()); currentPos = tuple.Item1.newPos; currentDir = tuple.Item1.dirToGetThere; Node newNode = new Node(currentPos, pathID, pathToBuildRemaining == 0 && pathID != 0); // Add to nodes list nodes.Add(newNode); // Add to dictionary of paths if (!paths.ContainsKey(pathID)) { paths.Add(pathID, new List <Node>()); } paths[pathID].Add(newNode); if (buildFromNode != null) { buildFromNode.doors.Add(currentDir, newNode); newNode.doors.Add(OppositeOrientation(currentDir), buildFromNode); } } return(true); }
public void LocationIsInitialized(ORIENTATION orientation) { var location = new Location(9266, 90210, orientation); Assert.That(location.Coordinate.X, Is.EqualTo(9266)); Assert.That(location.Coordinate.Y, Is.EqualTo(90210)); Assert.That(location.Orientation, Is.EqualTo(orientation)); }
private Tuple <PossibleBuild, int> GetPossibleBuild(int toBuildLeft, ORIENTATION previousDirection, Vector2 previousPosition, List <ORIENTATION> available) { List <ORIENTATION> directionsAvailable = available != null ? available : existingDirections.ToList(); // Ignore direction we built from before directionsAvailable.Remove(OppositeOrientation(previousDirection)); Tuple <bool, int> result; int smallestRemainingDepth = int.MaxValue; bool fallback = false; Vector2 fallbackPosition = new Vector2(); ORIENTATION fallbackDirection = ORIENTATION.NONE; Vector2 newPosition; ORIENTATION newDirection; do { newDirection = RandomizeDirection(previousDirection, directionsAvailable); newPosition = MoveIntoDirection(newDirection, previousPosition); directionsAvailable.Remove(newDirection); result = IsCellAvailable(new List <Vector2>(), newPosition, toBuildLeft); if (result.Item2 < smallestRemainingDepth) { smallestRemainingDepth = result.Item2; fallbackDirection = newDirection; fallbackPosition = newPosition; } if (result.Item1) { break; } if (directionsAvailable.Count == 0) { fallback = true; break; } }while (!result.Item1); // If no direction is possible for requested length pick the longest possible if (fallback) { return(new Tuple <PossibleBuild, int>(new PossibleBuild(fallbackPosition, fallbackDirection), smallestRemainingDepth)); } else { return(new Tuple <PossibleBuild, int>(new PossibleBuild(newPosition, newDirection), 0)); } }
public HudElement() { name = ""; position = new Vector2(0, 0); origin = position; size = position; state = VISIBILITY.SHOWN; orientation = ORIENTATION.TOP; action = null; }
public void LeftTurnsOrientation(ORIENTATION start, ORIENTATION finish) { var initialLocation = new Location(9266, 90210, start); var newLocation = motor.Move(initialLocation); Assert.That(newLocation.Coordinate.X, Is.EqualTo(9266)); Assert.That(newLocation.Coordinate.Y, Is.EqualTo(90210)); Assert.That(newLocation.Orientation, Is.EqualTo(finish)); }
public void Interact() { if (_currentOrientation == ORIENTATION.WEST) { _currentOrientation = ORIENTATION.NORTH; } else { ++_currentOrientation; } }
public Agent(Field field, ORIENTATION orientation) { Orientation = orientation; Food = 100; Coins = 0; Sprite = CreateSprite(orientation); SetField(field); }
public HudText(Vector2 pos, Vector2 siz, VISIBILITY vis, ORIENTATION ort, SpriteFont fnt, string txt, Action a) { position = pos; origin = pos; size = siz; state = vis; orientation = ort; font = fnt; text = txt; action = a; }
// Not real random but rather same direction as before or a chance to turn 90 degrees // Unless we are fed a ORIENTATION.NONE in which case the result can be anything available // If nothing is available returns ORIENTATION.NONE private ORIENTATION RandomizeDirection(ORIENTATION previousDirection, List <ORIENTATION> available) { List <ORIENTATION> directionsAvailable = available; // Ignore direction we built from before directionsAvailable.Remove(OppositeOrientation(previousDirection)); // Default behaviours if (directionsAvailable.Count == 0) { return(ORIENTATION.NONE); // Fail (Manage on the other side) } if (previousDirection == ORIENTATION.NONE) { return(directionsAvailable[Random.Range(0, directionsAvailable.Count)]); } // 1-3 directions possible onwards (forward/left/right) // Generate turns from our previous direction List <ORIENTATION> sidesAvailable = new List <ORIENTATION>(); sidesAvailable.Add(AngleToOrientation(OrientationToAngle(previousDirection) + 90f)); // Right sidesAvailable.Add(AngleToOrientation(OrientationToAngle(previousDirection) - 90f)); // Left // Only keep available sides sidesAvailable = sidesAvailable.Where(x => directionsAvailable.Contains(x)).ToList(); if (sidesAvailable.Count == 0) { return(previousDirection); // Has to be the only one remaining } else if (directionsAvailable.Contains(previousDirection)) { // 0-2 sides and forward remaining if (Random.Range(0f, 100f) < buildingDirectionChangeChance * 100f) { return(sidesAvailable[Random.Range(0, sidesAvailable.Count)]); } else { return(previousDirection); } } else { return(sidesAvailable[Random.Range(0, sidesAvailable.Count)]); // 0-2 sides remaining } }
IEnumerator AlignWithFloor(ORIENTATION currentFace) { flags["flipping"] = true; yield return(new WaitForSeconds(0.15f)); rbody.AddRelativeTorque(+0.004f * GetRollForceVector(currentFace), ForceMode.VelocityChange); yield return(new WaitForSeconds(0.15f)); rbody.AddRelativeTorque(-0.004f * GetRollForceVector(currentFace), ForceMode.VelocityChange); flags["flipping"] = false; }
private Vector2 MoveIntoDirection(ORIENTATION direction, Vector2 startPosition) { switch (direction) { case ORIENTATION.NORTH: return(new Vector2(startPosition.x, startPosition.y + 1)); case ORIENTATION.EAST: return(new Vector2(startPosition.x + 1, startPosition.y)); case ORIENTATION.SOUTH: return(new Vector2(startPosition.x, startPosition.y - 1)); case ORIENTATION.WEST: return(new Vector2(startPosition.x - 1, startPosition.y)); default: return(MoveIntoDirection(RandomizeDirection(direction, new List <ORIENTATION>()), startPosition)); } }
// Transform an ORIENTATION into direction public static Vector2Int OrientationToDir(ORIENTATION orientation) { switch (orientation) { case ORIENTATION.NORTH: return(new Vector2Int(0, 1)); case ORIENTATION.EAST: return(new Vector2Int(1, 0)); case ORIENTATION.SOUTH: return(new Vector2Int(0, -1)); case ORIENTATION.WEST: return(new Vector2Int(-1, 0)); default: return(new Vector2Int(0, 0)); } }
public static ORIENTATION OppositeOrientation(ORIENTATION orientation) { switch (orientation) { case ORIENTATION.NORTH: return(ORIENTATION.SOUTH); case ORIENTATION.EAST: return(ORIENTATION.WEST); case ORIENTATION.SOUTH: return(ORIENTATION.NORTH); case ORIENTATION.WEST: return(ORIENTATION.EAST); default: return(ORIENTATION.NONE); } }
public HudGraphic(string n, Vector2 pos, Vector2 siz, VISIBILITY vis, ORIENTATION ort, Texture2D tex, Action a) { name = n; position = pos; origin = pos; size = siz; state = vis; orientation = ort; texture = tex; action = a; //always not clicked on creation... clicked = false; //set up clickbox Point Pos = new Point((int)pos.X, (int)pos.Y); Point Size = new Point((int)size.X, (int)size.Y); clickBox = new Rectangle(Pos, Size); }
Vector3 GetRollForceVector(ORIENTATION facing) { switch (facing) { case ORIENTATION.SIDEWAYS_LEFT: return(new Vector3(0, 0, rollForce)); case ORIENTATION.SIDEWAYS_RIGHT: return(new Vector3(0, 0, -rollForce)); case ORIENTATION.UPSIDE_DOWN: return(new Vector3(1.5f * rollForce, 0, 0)); case ORIENTATION.FACE_DOWN: return(new Vector3(-rollForce, 0, 0)); case ORIENTATION.ON_BACK: return(new Vector3(rollForce, 0, 0)); } return(Vector3.zero); }
// Read the specified image into an ABGR-format rastertaking in account // specified orientation. public static bool TIFFReadRGBAImageOriented(TIFF tif, uint rwidth, uint rheight, uint[] raster, ORIENTATION orientation, bool stop) { string emsg=""; TIFFRGBAImage img=new TIFFRGBAImage(); bool ok; if(TIFFRGBAImageOK(tif, out emsg)&&TIFFRGBAImageBegin(img, tif, stop, out emsg)) { img.req_orientation=orientation; // XXX verify rwidth and rheight against width and height ok=TIFFRGBAImageGet(img, raster, (rheight-img.height)*rwidth, rwidth, img.height); TIFFRGBAImageEnd(img); } else { TIFFErrorExt(tif.tif_clientdata, TIFFFileName(tif), emsg); ok=false; } return ok; }
static void drawBeforeExplosion(int startPosition, ref int xPos, int yPos, ORIENTATION orientation) { Console.ForegroundColor = ConsoleColor.DarkGreen; if (orientation == ORIENTATION.RIGHT_TO_LEFT) { for (int i = startPosition; i > yPos; --i) { Program.drawElement('*', xPos - 1, i); // draw in current line Program.drawElement(' ', xPos, i + 1); // hide drawing in previos line --xPos; Thread.Sleep(300); } } else { if (orientation == ORIENTATION.UP) { for (int i = startPosition; i > yPos; --i) { Program.drawElement('*', xPos, i); // draw in current line Program.drawElement(' ', xPos, i + 1); // hide in previous line Thread.Sleep(400); } } else { for (int i = startPosition; i > yPos; --i) { Program.drawElement('*', xPos, i); //draw in current line Program.drawElement(' ', xPos - 1, i + 1); // hide in previous line ++xPos; Thread.Sleep(300); } } } }
IEnumerator MoveNextStage(ORIENTATION orientation) { yield return new WaitForFixedUpdate (); //Define a posiçao no centro da proxima tela e move a camera Vector3 newPos = new Vector3 (this.camera.transform.position.x , (this.WorldPos.y * this.currentStageY) + (this.WorldPos.y * (int)orientation), this.camera.transform.position.z); this.camera.transform.position = Vector3.MoveTowards (this.camera.transform.position, newPos, this.speedCamera * Time.deltaTime); //Confere a distancia para parar o movimento da camera. float currentDistance = Vector3.Distance (this.camera.transform.position, newPos); if (currentDistance > this.totalDistance/100) { StartCoroutine (MoveNextStage (orientation)); } else { this.cameraMoving = false; this.ResetWorldPos(); this.currentStageY += (int)orientation; print (this.currentStageY); // StopCoroutine(this.MoveNextStage(direction)); } }
// Transform an ORIENTATION into angle public static float OrientationToAngle(ORIENTATION orientation, ORIENTATION origin = ORIENTATION.NORTH) { float toNorthAngle = 0; switch (orientation) { case ORIENTATION.NORTH: toNorthAngle = 0.0f; break; case ORIENTATION.EAST: toNorthAngle = 90.0f; break; case ORIENTATION.SOUTH: toNorthAngle = 180.0f; break; case ORIENTATION.WEST: toNorthAngle = 270.0f; break; default: toNorthAngle = 270.0f; break; } if (origin == ORIENTATION.NORTH) { return(toNorthAngle); } float originToNorthAngle = OrientationToAngle(origin, ORIENTATION.NORTH); return(Mathf.Repeat(toNorthAngle - originToNorthAngle, 360.0f)); }
static void drawFirework(int xPos, int yPos, int startPosition, ORIENTATION orientation) { Program.drawBeforeExplosion(startPosition, ref xPos, yPos, orientation); Program.drawExplosion(xPos, yPos, orientation); }
public void Clear() { td_fieldsset=new uint[libtiff.FIELD_SETLONGS]; td_imagewidth=td_imagelength=td_imagedepth=0; td_tilewidth=td_tilelength=td_tiledepth=0; td_subfiletype=0; td_bitspersample=0; td_sampleformat=0; td_compression=0; td_photometric=0; td_threshholding=0; td_fillorder=0; td_orientation=0; td_samplesperpixel=0; td_rowsperstrip=0; td_minsamplevalue=td_maxsamplevalue=0; td_sminsamplevalue=td_smaxsamplevalue=0; td_xresolution=td_yresolution=0; td_resolutionunit=0; td_planarconfig=0; td_xposition=td_yposition=0; td_pagenumber=new ushort[2]; td_colormap=new ushort[3][]; td_halftonehints=new ushort[2]; td_extrasamples=0; td_sampleinfo=null; td_stripsperimage=0; td_nstrips=0; // size of offset & bytecount arrays td_stripoffset=null; td_stripbytecount=null; td_stripbytecountsorted=0; // is the bytecount array sorted ascending? td_nsubifd=0; td_subifd=null; // YCbCr parameters td_ycbcrsubsampling=new ushort[2]; td_ycbcrpositioning=0; // Colorimetry parameters td_refblackwhite=null; td_transferfunction=new ushort[3][]; // CMYK parameters td_inknameslen=0; td_inknames=null; td_customValueCount=0; td_customValues.Clear(); }
public void LocationHasDescription(ORIENTATION orientation) { var location = new Location(9266, 90210, orientation); Assert.That(location.Description, Is.EqualTo($"9266 90210 {orientation.ToString().First()}")); }
void CheckOrientation() { // only when NOT held or holding if (GetComponent <FixedJoint>() != null || claws != null) { return; } // only when NOT MOVING if (rbody.velocity.sqrMagnitude > 0.1f && mood != EMOTIONS.ASLEEP && mood != EMOTIONS.BORED) { return; } // use dot product float dot = 0; // check which vector is the closest to up dot = Vector3.Dot(transform.up, Vector3.up); if (dot > 0.5) { // no need to flip orientation = ORIENTATION.RIGHT_SIDE_UP; return; } else { // if the cat is not right side up, flip flipTimer += 2f * Time.fixedDeltaTime; // flip if (flipTimer > waitBeforeFlipDuration) { flipTimer = 0; FlipUpwards(); } } if (dot < -0.5) { orientation = ORIENTATION.UPSIDE_DOWN; return; } // left right dot = Vector3.Dot(transform.right, Vector3.up); if (dot > 0.5) { orientation = ORIENTATION.SIDEWAYS_RIGHT; return; } if (dot < -0.5) { orientation = ORIENTATION.SIDEWAYS_LEFT; return; } // back front dot = Vector3.Dot(transform.forward, Vector3.up); if (dot > 0.5) { orientation = ORIENTATION.ON_BACK; return; } if (dot < -0.5) { orientation = ORIENTATION.FACE_DOWN; return; } }
public IForwardMotor ConstructForwardFor(ORIENTATION orientation) { return(kernel.Get <IForwardMotor>(orientation.ToString())); }
public void setOrientation(ORIENTATION o) { orientation = o; }
static void drawExplosion(int xPos, int yPos, ORIENTATION orientation) { if (orientation == ORIENTATION.LEFT_TO_RIGHT) { int j = 0; int indexToHide = 0; // radius of explosion for (int i = 0; i < 5; ++i) { // change colors while drawing Console.ForegroundColor = (ConsoleColor)j; // draw explosion Program.drawExplodePositions('*', xPos, yPos, j); // remove drawings when startPosition beginning if j is bigger than const value if (j > Program.START_HIDING_COUNT) { Program.drawExplodePositions(' ', xPos, yPos, indexToHide++); } ++j; Thread.Sleep(380); } j = 0; // hide the rest of explosion while (j <= Program.START_HIDING_COUNT) { Program.drawExplodePositions(' ', xPos, yPos, indexToHide++); j++; Thread.Sleep(380); } } else { if (orientation == ORIENTATION.UP) { int j = 0; int indexToHide = 0; for (int i = 0; i < 7; ++i) { Console.ForegroundColor = (ConsoleColor)j; Program.drawExplodePositions('*', xPos, yPos, j); if (j > Program.START_HIDING_COUNT) { Program.drawExplodePositions(' ', xPos, yPos, indexToHide++); } ++j; Thread.Sleep(500); } j = 0; while (j <= Program.START_HIDING_COUNT) { Program.drawExplodePositions(' ', xPos, yPos, indexToHide++); j++; Thread.Sleep(500); } } else { int j = 0; int indexToHide = 0; // for (int i = 0; i < 4; ++i) { Console.ForegroundColor = (ConsoleColor)i; Program.drawExplodePositions('*', xPos, yPos, j); if (j > Program.START_HIDING_COUNT) { Program.drawExplodePositions(' ', xPos, yPos, indexToHide++); } ++j; Thread.Sleep(380); } j = 0; while (j <= Program.START_HIDING_COUNT) { Program.drawExplodePositions(' ', xPos, yPos, indexToHide++); j++; Thread.Sleep(380); } } } }
public GradientType() { this.orientationField = ORIENTATION.HORIZONTAL; }