/** * Called by <code>FlxGame</code> to set up <code>FlxG</code> during <code>FlxGame</code>'s constructor. */ static internal void setGameData(FlxGame Game, int Width, int Height) { _game = Game; width = Width; height = Height; _mute = false; _volume = 0.5f; FlxG.camera = new FlxCamera(); FlxG.camera.unfollow(); level = 0; score = 0; pause = false; timeScale = 1.0f; maxElapsed = 0.0333f; FlxG.elapsed = 0; showBounds = false; #if !WINDOWS_PHONE mobile = false; #else mobile = true; #endif FlxU.setWorldBounds(0, 0, FlxG.width, FlxG.height); }
/// <summary> /// Looks for any tiles that are "ground tiles" /// ! = new tile. /// !00! /// 1!!1 /// 1111 /// 0000 /// </summary> /// <param name="inMat">multi array to analyse</param> /// <param name="ratio">0-1 how much chance of returning a solid block</param> /// <returns>multi array that has decorations only</returns> public int[,] createDecorationsMap(int[,] inMat, float ratio) { Console.WriteLine("Create Decorations map"); int numRows = inMat.GetLength(0); int numCols = inMat.GetLength(1); int[,] outMat = this.genInitMatrix(_numTilesRows, _numTilesCols); for (int _y = 1; _y < numRows - 2; _y++) { for (int _x = 1; _x < numCols - 1; _x++) { // test for flat surface with empty above if (inMat[_y, _x] == 0 && inMat[_y + 1, _x] == 1 && inMat[_y + 1, _x - 1] == 1 && inMat[_y + 1, _x + 1] == 1) { if (FlxU.random() < ratio) { outMat[_y, _x] = 1; } else { outMat[_y, _x] = 0; } } else { outMat[_y, _x] = 0; } } } return(outMat); }
/// <summary> /// Finds a random empty spot /// </summary> /// <param name="inMat">Matrix to search</param> /// <returns>int[] array {rx, ry} of a empty spot</returns> public int[] findRandomEmpty(int[,] inMat) { //Console.WriteLine("Find Random Empty"); int numRows = inMat.GetLength(0); int numCols = inMat.GetLength(1); int n = 0; int rx = 0; int ry = 0; while (n != 1) { rx = (int)(FlxU.random() * (numRows - 1)); ry = (int)(FlxU.random() * (numCols - 1)); if (inMat[rx, ry] == 0) { n = 1; //Console.WriteLine("X:" + rx + "Y:" + ry); } } return(new int[] { rx, ry }); }
protected void drawBounds(SpriteBatch spriteBatch, int X, int Y) { spriteBatch.Draw(FlxG.XnaSheet, new Rectangle((int)(FlxU.floor(x + FlxU.roundingError) + FlxU.floor(FlxG.scroll.X * scrollFactor.X)), (int)(FlxU.floor(y + FlxU.roundingError) + FlxU.floor(FlxG.scroll.Y * scrollFactor.Y)), (int)width, (int)height), new Rectangle(1, 1, 1, 1), getBoundingColor()); }
/** * Call this function to figure out the on-screen position of the object. * * @param P Takes a <code>Point</code> object and assigns the post-scrolled X and Y values of this object to it. * * @return The <code>Point</code> you passed in, or a new <code>Point</code> if you didn't pass one, containing the screen X and Y position of this object. */ virtual public Vector2 getScreenXY() { Vector2 Point = Vector2.Zero; Point.X = FlxU.floor(x + FlxU.roundingError) + FlxU.floor(FlxG.scroll.X * scrollFactor.X); Point.Y = FlxU.floor(y + FlxU.roundingError) + FlxU.floor(FlxG.scroll.Y * scrollFactor.Y); return(Point); }
/// <summary> /// Call this function to figure out the on-screen position of the object. /// /// Takes a <code>Point</code> object and assigns the post-scrolled X and Y values of this object to it. /// </summary> /// <returns>The <code>Point</code> you passed in, or a new <code>Point</code> if you didn't pass one, containing the screen X and Y position of this object.</returns> override public Vector2 getScreenXY() { Vector2 Point = Vector2.Zero; Point.X = FlxU.floor(x + FlxU.roundingError) + FlxU.floor(FlxG.scroll.X * scrollFactor.X) - offset.X; Point.Y = FlxU.floor(y + FlxU.roundingError) + FlxU.floor(FlxG.scroll.Y * scrollFactor.Y) - offset.Y; return(Point); }
/// <summary> /// An internal function used by the binary auto-tilers. /// </summary> /// <param name="Index">The index of the tile you want to analyze.</param> protected void randomTile(int Index) { if (_data[Index] == 0) { return; } _data[Index] = (int)(FlxU.random() * randomLimit); }
/// <summary> /// An internal function used by the binary auto-tilers. /// </summary> /// <param name="Index">The index of the tile you want to analyze.</param> protected void autoTileWithRemap(int Index) { if (_data[Index] == 0) { return; } _data[Index] = 0; if ((Index - widthInTiles < 0) || (_data[Index - widthInTiles] > 0)) //UP { _data[Index] += 1; } if ((Index % widthInTiles >= widthInTiles - 1) || (_data[Index + 1] > 0)) //RIGHT { _data[Index] += 2; } if ((Index + widthInTiles >= totalTiles) || (_data[Index + widthInTiles] > 0)) //DOWN { _data[Index] += 4; } if ((Index % widthInTiles <= 0) || (_data[Index - 1] > 0)) //LEFT { _data[Index] += 8; } if ((auto == REMAPALT) && (_data[Index] == 15)) //The alternate algo checks for interior corners { if ((Index % widthInTiles > 0) && (Index + widthInTiles < totalTiles) && (_data[Index + widthInTiles - 1] <= 0)) { _data[Index] = 1; //BOTTOM LEFT OPEN } if ((Index % widthInTiles > 0) && (Index - widthInTiles >= 0) && (_data[Index - widthInTiles - 1] <= 0)) { _data[Index] = 2; //TOP LEFT OPEN } if ((Index % widthInTiles < widthInTiles - 1) && (Index - widthInTiles >= 0) && (_data[Index - widthInTiles + 1] <= 0)) { _data[Index] = 4; //TOP RIGHT OPEN } if ((Index % widthInTiles < widthInTiles - 1) && (Index + widthInTiles < totalTiles) && (_data[Index + widthInTiles + 1] <= 0)) { _data[Index] = 8; //BOTTOM RIGHT OPEN } } if (remapGuide.ContainsKey(_data[Index])) { int count = FlxU.randomInt(0, remapGuide[_data[Index]].Length - 1); _data[Index] = remapGuide[_data[Index]][count]; } else { _data[Index] = remapGuide[0][0]; } _data[Index] += 1; }
protected void drawPivot(SpriteBatch spriteBatch, int X, int Y, Color col) { spriteBatch.Draw(FlxG.XnaSheet, new Rectangle((int)(FlxU.floor(X + FlxU.roundingError) + FlxU.floor(FlxG.scroll.X * scrollFactor.X)), (int)(FlxU.floor(Y + FlxU.roundingError) + FlxU.floor(FlxG.scroll.Y * scrollFactor.Y)), 1, 1), new Rectangle(1, 1, 1, 1), col); }
/// <summary> /// Checks for overlaps between the provided object and any tiles above the collision index. /// </summary> /// <param name="Core">The <code>FlxObject</code> you want to check against.</param> /// <returns>True if overlap occurs, otherwise False</returns> override public bool overlaps(FlxObject Core) { int d; int dd; List <BlockPoint> blocks = new List <BlockPoint>(); //First make a list of all the blocks we'll use for collision int ix = (int)FlxU.floor((Core.x - x) / _tileWidth); int iy = (int)FlxU.floor((Core.y - y) / _tileHeight); int iw = (int)FlxU.ceil((float)Core.width / (float)_tileWidth) + 1; int ih = (int)FlxU.ceil((float)Core.height / (float)_tileHeight) + 1; int r = 0; int c; while (r < ih) { if (r >= heightInTiles) { break; } d = (iy + r) * widthInTiles + ix; c = 0; while (c < iw) { if (c >= widthInTiles) { break; } dd = _data[d + c]; if (dd >= collideMin && dd >= collideMax) { blocks.Add(new BlockPoint((int)(x + (ix + c) * _tileWidth), (int)(y + (iy + r) * _tileHeight), dd)); } c++; } r++; } //Then check for overlaps int bl = blocks.Count; int i = 0; while (i < bl) { _block.x = blocks[i].x; _block.y = blocks[i++].y; if (_block.overlaps(Core)) { return(true); } } return(false); }
virtual public bool overlapsPoint(float X, float Y, bool PerPixel) { X = X + FlxU.floor(FlxG.scroll.X); Y = Y + FlxU.floor(FlxG.scroll.Y); _point = getScreenXY(); if ((X <= _point.X) || (X >= _point.X + width) || (Y <= _point.Y) || (Y >= _point.Y + height)) { return(false); } return(true); }
public override void updateFlickering() { base.updateFlickering(); if (flickering()) { if (flickerStyle == FLICKER_TYPE_SCALE) { scale = FlxU.random(0.9f, 1.1f); } } }
/// <summary> /// An internal function used by the binary auto-tilers. /// </summary> /// <param name="Index">The index of the tile you want to analyze.</param> protected void autoTile(int Index) { if (_data[Index] == 0) { return; } _data[Index] = 0; if ((Index - widthInTiles < 0) || (_data[Index - widthInTiles] > 0)) //UP { _data[Index] += 1; } if ((Index % widthInTiles >= widthInTiles - 1) || (_data[Index + 1] > 0)) //RIGHT { _data[Index] += 2; } if ((Index + widthInTiles >= totalTiles) || (_data[Index + widthInTiles] > 0)) //DOWN { _data[Index] += 4; } if ((Index % widthInTiles <= 0) || (_data[Index - 1] > 0)) //LEFT { _data[Index] += 8; } if ((auto == ALT) && (_data[Index] == 15)) //The alternate algo checks for interior corners { if ((Index % widthInTiles > 0) && (Index + widthInTiles < totalTiles) && (_data[Index + widthInTiles - 1] <= 0)) { _data[Index] = 1; //BOTTOM LEFT OPEN } if ((Index % widthInTiles > 0) && (Index - widthInTiles >= 0) && (_data[Index - widthInTiles - 1] <= 0)) { _data[Index] = 2; //TOP LEFT OPEN } if ((Index % widthInTiles < widthInTiles - 1) && (Index - widthInTiles >= 0) && (_data[Index - widthInTiles + 1] <= 0)) { _data[Index] = 4; //TOP RIGHT OPEN } if ((Index % widthInTiles < widthInTiles - 1) && (Index + widthInTiles < totalTiles) && (_data[Index + widthInTiles + 1] <= 0)) { _data[Index] = 8; //BOTTOM RIGHT OPEN } } _data[Index] += 1; if (useExtraMiddleTiles) { if (_extraMiddleTiles >= 1 && _data[Index] == 16) { _data[Index] += (int)(FlxU.random() * (_extraMiddleTiles + 1)); } } }
/// <summary> /// <code>FlxU.collide()</code> (and thus <code>FlxObject.collide()</code>) call /// this function each time two objects are compared to see if they collide. /// It doesn't necessarily mean these objects WILL collide, however. /// </summary> /// <param name="Object">The <code>FlxObject</code> you're about to run into.</param> override public void preCollide(FlxObject Object) { //Collision fix, in case updateMotion() is called colHullX.x = 0; colHullX.y = 0; colHullY.x = 0; colHullY.y = 0; int r; int c; int rs; int ix = (int)FlxU.floor((Object.x - x) / _tileWidth); int iy = (int)FlxU.floor((Object.y - y) / _tileHeight); int iw = ix + (int)FlxU.ceil((float)Object.width / (float)_tileWidth) + 1; int ih = iy + (int)FlxU.ceil((float)Object.height / (float)_tileHeight) + 1; if (ix < 0) { ix = 0; } if (iy < 0) { iy = 0; } if (iw > widthInTiles) { iw = widthInTiles; } if (ih > heightInTiles) { ih = heightInTiles; } rs = iy * widthInTiles; r = iy; colOffsets.Clear(); while (r < ih) { c = ix; while (c < iw) { if (_data[rs + c] >= collideMin && _data[rs + c] <= collideMax) { colOffsets.Add(new Vector2(x + c * _tileWidth, y + r * _tileHeight)); } c++; } rs += widthInTiles; r++; } }
/** * Returns a member at random from the group. * * @return A <code>FlxObject</code> from the members list. */ public FlxObject getRandom() { int c = 0; FlxObject o = null; int l = members.Count; int i = (int)(FlxU.random() * l); while ((o == null) && (c < members.Count)) { o = members[(++i) % l] as FlxObject; c++; } return(o); }
public void startPlayingBack(string Filename) { _history = new List <bool[]>(); string x = FlxU.loadFromDevice(Filename); string[] y = x.Split('\n'); int line = 0; foreach (var item in y) { string[] item1 = item.Split(','); line++; if (item1.Length == 14) { try { _history.Add(new bool[] { bool.Parse(item1[0]), bool.Parse(item1[1]), bool.Parse(item1[2]), bool.Parse(item1[3]), bool.Parse(item1[4]), bool.Parse(item1[5]), bool.Parse(item1[6]), bool.Parse(item1[7]), bool.Parse(item1[8]), bool.Parse(item1[9]), bool.Parse(item1[10]), bool.Parse(item1[11]), bool.Parse(item1[12]), bool.Parse(item1[13]) }); } catch (Exception) { Console.WriteLine("History Not Added " + item1.Length + " -- " + item1[1]); } } } //_rec = Recording.Playback; control = Controls.file; frameCount = 0; }
/// <summary> /// Get a position of any tile that matches Tiles /// </summary> /// <param name="Tiles">Provide an array of tiles you want to match.</param> /// <returns></returns> public Vector2 getRandomTilePositionWithType(int[] Tiles) { int[] empties = remapGuide[15]; int rx = FlxU.randomInt(0, widthInTiles); int ry = FlxU.randomInt(0, heightInTiles); int rz = getTile(rx, ry); while (empties.Contains(rz) == false) { rx = FlxU.randomInt(0, widthInTiles); ry = FlxU.randomInt(0, heightInTiles); rz = getTile(rx, ry); } return(new Vector2(rx * _tileWidth, ry * _tileHeight)); }
/// <summary> /// Get a random tile with the type you specify. /// </summary> /// <param name="Tiles">Array of tiles you want to search for.</param> /// <returns></returns> public int getRandomTileWithType(int[] Tiles) { int[] empties = remapGuide[15]; int rx = FlxU.randomInt(0, widthInTiles); int ry = FlxU.randomInt(0, heightInTiles); int rz = getTile(rx, ry); while (empties.Contains(rz) == false) { rx = FlxU.randomInt(0, widthInTiles); ry = FlxU.randomInt(0, heightInTiles); rz = getTile(rx, ry); } return(rz); }
/// <summary> /// The Update Cycle. Called once every cycle. /// </summary> override public void update() { if (angle != 0) { if (alpha > 0) { if (FlxU.random() > 0.5f) { alpha -= 0.1f; } } } y = t.Position; t.Update(FlxG.elapsedAsGameTime); base.update(); }
/// <summary> /// Specify the boundaries of the level or where the camera is allowed to move. /// </summary> /// <param name="MinX">The smallest X value of your level (usually 0).</param> /// <param name="MinY">The smallest Y value of your level (usually 0).</param> /// <param name="MaxX">The largest X value of your level (usually the level width).</param> /// <param name="MaxY">The largest Y value of your level (usually the level height).</param> /// <param name="UpdateWorldBounds">Whether the quad tree's dimensions should be updated to match.</param> static public void followBounds(int MinX, int MinY, int MaxX, int MaxY, bool UpdateWorldBounds) { followMin = new Point(-MinX, -MinY); followMax = new Point(-MaxX + width, -MaxY + height); if (followMax.X > followMin.X) { followMax.X = followMin.X; } if (followMax.Y > followMin.Y) { followMax.Y = followMin.Y; } if (UpdateWorldBounds) { FlxU.setWorldBounds(MinX, MinY, MaxX - MinX, MaxY - MinY); } doFollow(); }
/** * Updates and/or animates this special effect. */ public void update() { if (_timer > 0) { _timer -= FlxG.elapsed; if (_timer <= 0) { _timer = 0; x = 0; y = 0; } else { x = (int)(FlxU.random() * _intensity * FlxG.width * 2 - _intensity * FlxG.width) * _zoom; y = (int)(FlxU.random() * _intensity * FlxG.height * 2 - _intensity * FlxG.height) * _zoom; } } }
public void saveRecording() { string _historyString = ""; foreach (var item in _history) { _historyString += item[0].ToString() + "," + item[1].ToString() + "," + item[2].ToString() + "," + item[3].ToString() + "," + item[4].ToString() + "," + item[5].ToString() + "," + item[6].ToString() + "," + item[7].ToString() + "," + item[8].ToString() + "," + item[9].ToString() + "," + item[10].ToString() + "," + item[11].ToString() + "," + item[12].ToString() + "," + item[13].ToString() + "\n"; } FlxU.saveToDevice(_historyString, (filename + "_" + DateTime.Now.Ticks.ToString() + ".txt")); infoText.text = "Saved file to device: " + filename + "_" + DateTime.Now.Ticks.ToString() + ".txt"; _rec = Recording.None; }
/// <summary> /// Generates a completely random set of 1s and 0s. /// </summary> /// <returns>Returns a matrix of a cave!</returns> public int[,] generateCaveLevel() { // Initialize random array int[,] mat = new int[_numTilesRows, _numTilesCols]; mat = this.genInitMatrix(_numTilesRows, _numTilesCols); int floor = _numTilesRows - 2; for (int _y = 0; _y < _numTilesRows; _y++) { for (int _x = 0; _x < _numTilesCols; _x++) { //Throw in a random assortment of ones and zeroes. if (FlxU.random() < initWallRatio) { mat[_y, _x] = 1; } else { mat[_y, _x] = 0; } } } // Secondary buffer int[,] mat2 = genInitMatrix(_numTilesRows, _numTilesCols); // Run automata for (int i = 0; i <= numSmoothingIterations; i++) { runCelluarAutomata(mat, mat2); int[,] temp = new int[mat.GetLength(0), mat.GetLength(1)]; mat = mat2; mat2 = temp; } return(mat); }
//public void setAngleBasedOnVelocity() //{ // double rot = Math.Atan2((float)velocity.Y, (float)velocity.X); // double degrees = rot * 180 / Math.PI; // angle = (float)degrees; //} /// <summary> /// Draws bounds /// </summary> /// <param name="spriteBatch">Sprite Batch</param> /// <param name="X">X</param> /// <param name="Y">Y</param> protected void drawBounds(SpriteBatch spriteBatch, int X, int Y) { spriteBatch.Draw(FlxG.XnaSheet, new Rectangle((int)(FlxU.floor(x + FlxU.roundingError) + FlxU.floor(FlxG.scroll.X * scrollFactor.X)), (int)(FlxU.floor(y + FlxU.roundingError) + FlxU.floor(FlxG.scroll.Y * scrollFactor.Y)), (int)width, (int)height), new Rectangle(1, 1, 1, 1), getBoundingColor()); if (path != null) { //int count = 0; // Draw a square for each node in a path //foreach (var item in path.nodes) //{ // spriteBatch.Draw(FlxG.XnaSheet, // new Rectangle((int)item.X - 2 + (int)(FlxU.floor(FlxG.scroll.X * scrollFactor.X)), // (int)item.Y - 2 + (int)(FlxU.floor(FlxG.scroll.Y * scrollFactor.Y)), // 4, // 4), // new Rectangle(1, 1, 1, 1), // Color.DarkOrange); //} // Draw a line for each node for (int i = 0; i < path.nodes.Count - 1; i++) { #if !__ANDROID__ spriteBatch.DrawLine(new Vector2((int)path.nodes[i].X - 2 + (int)(FlxU.floor(FlxG.scroll.X * scrollFactor.X)), (int)path.nodes[i].Y - 2 + (int)(FlxU.floor(FlxG.scroll.Y * scrollFactor.Y))), new Vector2((int)path.nodes[i + 1].X - 2 + (int)(FlxU.floor(FlxG.scroll.X * scrollFactor.X)), (int)path.nodes[i + 1].Y - 2 + (int)(FlxU.floor(FlxG.scroll.Y * scrollFactor.Y))), Color.DarkOrange, 1.0f); #endif } } }
virtual public FlxSprite emitParticleAndReturnSprite() { _counter++; FlxSprite s = members[_particle] as FlxSprite; s.visible = true; s.exists = true; s.active = true; s.x = x - ((int)s.width >> 1) + FlxU.random() * width; s.y = y - ((int)s.height >> 1) + FlxU.random() * height; s.velocity.X = minParticleSpeed.X; if (minParticleSpeed.X != maxParticleSpeed.X) { s.velocity.X += FlxU.random() * (maxParticleSpeed.X - minParticleSpeed.X); } s.velocity.Y = minParticleSpeed.Y; if (minParticleSpeed.Y != maxParticleSpeed.Y) { s.velocity.Y += FlxU.random() * (maxParticleSpeed.Y - minParticleSpeed.Y); } s.acceleration.Y = gravity; s.angularVelocity = minRotation; if (minRotation != maxRotation) { s.angularVelocity += FlxU.random() * (maxRotation - minRotation); } if (s.angularVelocity != 0) { s.angle = FlxU.random() * 360 - 180; } s.drag.X = particleDrag.X; s.drag.Y = particleDrag.Y; _particle++; if (_particle >= members.Count) { _particle = 0; } s.onEmit(); justEmitted = true; return(s); }
/// <summary> /// Add Decorations such as top, right, etc decorations. /// </summary> /// <param name="mat">In Matrix</param> /// <param name="Chance">Chance of adding.</param> /// <returns>a string[,] matrix cave.</returns> public string[,] addDecorations(string[,] mat, float Chance) { for (int x = 0; x < mat.GetLength(1); x++) { for (int y = 0; y < mat.GetLength(0); y++) { if (FlxU.random() <= Chance) { string value = mat[y, x]; if (value == "8" && coordIsInMatrix(mat, x - 1, y)) { mat[y, x - 1] = ((int)FlxU.random(TOP_DECORATION_MIN, TOP_DECORATION_MAX)).ToString(); } if (value == "14" && coordIsInMatrix(mat, x + 1, y)) { mat[y, x + 1] = UNDER_DECORATION; } if (value == "13" && coordIsInMatrix(mat, x + 1, y)) { mat[y, x + 1] = TOP_RIGHT_DECORATION; } if (value == "10" && coordIsInMatrix(mat, x + 1, y)) { mat[y, x + 1] = UNDER_LEFT_DECORATION; } if (value == "7" && coordIsInMatrix(mat, x - 1, y)) { mat[y, x - 1] = TOP_LEFT_DECORATION; } if (value == "4" && coordIsInMatrix(mat, x - 1, y)) { mat[y, x - 1] = UNDER_RIGHT_DECORATION; } } } } return(mat); }
/// <summary> /// Finds a random solid piece in a Matrix /// </summary> /// <param name="inMat">Matrix to search</param> /// <returns>int[] array {rx, ry} of a solid</returns> public int[] findRandomSolid(int[,] inMat) { //Console.WriteLine("Find Random Solid"); int numRows = inMat.GetLength(0); int numCols = inMat.GetLength(1); int n = 0; int rx = (int)(FlxU.random() * (numRows - 1)); int ry = (int)(FlxU.random() * (numCols - 1)); if (inMat[rx, ry] == 1) { return(new int[] { rx, ry }); } else { while (n != 1) { rx++; ry++; if (rx > numRows - 1) { rx = (int)(FlxU.random() * (numRows - 1)); } if (ry > numRows - 1) { ry = (int)(FlxU.random() * (numCols - 1)); } if (inMat[rx, ry] == 1) { n = 1; } } } return(new int[] { rx, ry }); }
public int[,] generateBridgeLevel(int NumberOfLadders, int MinLength, int MaxLength) { Console.WriteLine("generateBridgeLevel"); // Initialize random array int[,] mat = new int[_numTilesRows, _numTilesCols]; mat = this.genInitMatrix(_numTilesRows, _numTilesCols); for (int i = 0; i < NumberOfLadders; i++) { int length = (int)(FlxU.random(MinLength, MaxLength)); int _x = (int)(FlxU.random(0, _numTilesRows)); int _y = (int)(FlxU.random(0, _numTilesCols - length)); for (int j = 0; j < length; j++) { mat[_y + j, _x] = 1; } } return(mat); }
/// <summary> /// Just updates the render-style flickering. /// </summary> public virtual void updatecolorFlickering() { if (colorFlickering()) { if (_colorFlickerTimer > 0) { _colorFlickerTimer -= FlxG.elapsed; if (_colorFlickerTimer == 0) { _colorFlickerTimer = -1; } } if (_colorFlickerTimer < 0) { colorFlicker(-1); } else { _colorFlicker = !_colorFlicker; if (_colorFlicker) { color = new Color(0.99f, 0.99f, 0.99f); } else if (!_colorFlicker) { color = new Color( FlxU.random(_colorFlickerRMin, _colorFlickerRMax), FlxU.random(_colorFlickerGMin, _colorFlickerGMax), FlxU.random(_colorFlickerBMin, _colorFlickerBMax)); } } } else { color = _lastColor; } }
/// <summary> /// Checks to see if a point in 2D space overlaps this FlxCore object. /// </summary> /// <param name="X">The X coordinate of the point.</param> /// <param name="Y">The Y coordinate of the point.</param> /// <param name="PerPixel">Whether or not to use per pixel collision checking.</param> /// <returns>Whether or not the point overlaps this object.</returns> override public bool overlapsPoint(float X, float Y, bool PerPixel) { X = X + FlxU.floor(FlxG.scroll.X); Y = Y + FlxU.floor(FlxG.scroll.Y); _point = getScreenXY(); //if(PerPixel) // return _framePixels.hitTest(new Point(0,0),0xFF,new Point(X-_point.x,Y-_point.y)); //else if (_stretchToFit == false) { if ((X <= _point.X) || (X >= _point.X + frameWidth) || (Y <= _point.Y) || (Y >= _point.Y + frameHeight)) { return(false); } } else { if ((X <= _point.X) || (X >= _point.X + width) || (Y <= _point.Y) || (Y >= _point.Y + height)) { return(false); } } return(true); }