public void giveExp(int exp, Vector3 expPosition)
{
this.stats.exp += exp;
this.UIPlayer.updateInfo();
this.UIPlayer.spawnActionText(expPosition, "+" + exp + "XP", ColorExt.xpColor(), Tools.TEXT_SPEED / 4);
Debug.Log("PLAYER GIVEN EXP WITH POSITION: " + exp);
}
public bool[,] GetPattern(Bitmap shot)
{
BitmapData srcData = shot.LockBits(new Rectangle(0, 0, shot.Width, shot.Height), ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);
IntPtr Scan0 = srcData.Scan0;
int stride = srcData.Stride;
int width = shot.Width;
int height = shot.Height;
bool[,] result = new bool[width, height];
unsafe
{
byte *p = (byte *)(void *)Scan0;
for (int x = 0; x < width; x++)
{
for (int y = 0; y < height; y++)
{
int idx = (y * stride) + x * 4;
double distance = ColorExt.GetHueDistance(p[idx + 2], p[idx + 1], p[idx + 0], HexagonCellImage.COLOR_CELL_HIDDEN);
result[x, y] = (distance < 16.875);
}
}
}
shot.UnlockBits(srcData);
return(result);
}
public void Update()
{
Entity.SetPosition(Input.MousePosition);
if (Input.IsKeyDown(Keys.W))
{
_light.Radius += 10;
}
else if (Input.IsKeyDown(Keys.S))
{
_light.Radius -= 10;
}
Entity.Scale = Vector2.Clamp(Entity.Scale, new Vector2(0.2f), new Vector2(30));
if (Input.IsKeyDown(Keys.A))
{
var(h, s, l) = ColorExt.RgbToHsl(_light.Color);
_light.Color = ColorExt.HslToRgb((h - 0.002f) % 360, s, l);
}
else if (Input.IsKeyDown(Keys.D))
{
var(h, s, l) = ColorExt.RgbToHsl(_light.Color);
_light.Color = ColorExt.HslToRgb((h + 0.002f) % 360, s, l);
}
if (Input.LeftMouseButtonPressed)
{
var clone = Entity.Clone(Entity.Position);
clone.RemoveComponent <LiveLightController>();
Entity.Scene.AddEntity(clone);
}
}
private void SetupMapObjects()
{
var mapObjects = _tiledMap.getObjectGroup(TiledObjects.ObjectGroup);
SetupCollisions(mapObjects);
SetupPits(mapObjects);
SetupItemSpawners(mapObjects);
SetupPlayerSpawns(mapObjects);
SetupMapEvents(mapObjects);
foreach (var lightSource in mapObjects.objectsWithName("light_source"))
{
var entity = scene.createEntity("world-light", lightSource.position + new Vector2(8, 8));
entity.setScale(0.5f);
var sprite = entity.addComponent(new Sprite(AssetLoader.GetTexture("effects/lightmask_xs")));
sprite.material = Material.blendLinearDodge();
sprite.color = ColorExt.hexToColor("#" + lightSource.properties["color"].Substring(2));
sprite.renderLayer = Layers.Lights;
var props = lightSource.properties;
if (props.ContainsKey("toggle_key") && !string.IsNullOrWhiteSpace(props["toggle_key"]))
{
var listener = entity.addComponent(new MapEventListener(props["toggle_key"])
{
EventTriggered = _ =>
{
entity.setEnabled(!entity.enabled);
}
});
MapEventListeners.Add(listener);
}
}
}
public override OgmoValueDefinition ReadJson(JsonReader reader, Type objectType, OgmoValueDefinition existingValue, bool hasExistingValue, JsonSerializer serializer)
{
JObject obj = JObject.Load(reader);
switch ((string)obj["definition"])
{
case "String":
var strValue = new OgmoStringValueDefinition();
strValue.Name = (string)obj["name"];
strValue.Default = (string)obj["defaults"];
strValue.MaxLength = (int)obj["maxLength"];
strValue.TrimWhitespace = (bool)obj["trimWhitespace"];
return(strValue);
case "Text":
var textValue = new OgmoTextValueDefinition();
textValue.Name = (string)obj["name"];
textValue.Default = (string)obj["defaults"];
return(textValue);
case "Enum":
var enumValue = new OgmoEnumValueDefinition();
enumValue.Name = (string)obj["name"];
var arr = obj["choices"].Children().ToArray();
var finalChoices = new string[arr.Length];
for (int i = 0; i < arr.Length; i++)
{
finalChoices[i] = (string)arr[i];
}
enumValue.Choices = finalChoices;
enumValue.Default = (int)obj["defaults"];
return(enumValue);
case "Integer":
var intValue = new OgmoIntegerValueDefinition();
intValue.Name = (string)obj["name"];
intValue.Default = (int)obj["defaults"];
intValue.Bounded = (bool)obj["bounded"];
intValue.Min = (int)obj["min"];
intValue.Max = (int)obj["max"];
return(intValue);
case "Float":
var floatValue = new OgmoFloatValueDefinition();
floatValue.Name = (string)obj["name"];
floatValue.Default = (float)obj["defaults"];
floatValue.Bounded = (bool)obj["bounded"];
floatValue.Min = (float)obj["min"];
floatValue.Max = (float)obj["max"];
return(floatValue);
case "Color":
var colValue = new OgmoColorValueDefinition();
colValue.Name = (string)obj["name"];
colValue.Default = ColorExt.HexToColor((string)obj["defaults"]);
colValue.IncludeAlpha = (bool)obj["includeAlpha"];
return(colValue);
}
return(null);
}
public void Draw(Camera camera)
{
uniShader.Parameters["WVP"].SetValue(camera.WVP);
uniShader.Parameters["Model"].SetValue(Transform.Matrix);
uniShader.Parameters["Normal"].SetValue(Transform.Normal);
uniShader.Parameters["Tint"].SetValue(Tint.ToVector4());
uniShader.Parameters["Shininess"].SetValue(Material.Shininess);
uniShader.Parameters["CameraPosition"].SetValue(camera.Position);
uniShader.Parameters["EnvironmentColor"].SetValue((ColorExt.CreateFromHex("#514493") * 0.5f).ToVector3());
uniShader.Parameters["DiffuseMap"].SetValue(Material.DiffuseMap);
uniShader.Parameters["NormalMap"].SetValue(Material.NormalMap);
uniShader.Parameters["SpecularMap"].SetValue(Material.SpecularMap);
uniShader.Parameters["LightOneDirection"].SetValue(new Vector3(1, -2, 3));
uniShader.Parameters["LightOneDiffuse"].SetValue((ColorExt.CreateFromHex("#ff9000") * 0.6f).ToVector3());
uniShader.Parameters["LightOneSpecular"].SetValue((ColorExt.CreateFromHex("#546aff") * 0.4f).ToVector3());
uniShader.Parameters["LightTwoDirection"].SetValue(new Vector3(-3, 1, -2));
uniShader.Parameters["LightTwoDiffuse"].SetValue((ColorExt.CreateFromHex("#546aff") * 0.6f).ToVector3());
uniShader.Parameters["LightTwoSpecular"].SetValue((ColorExt.CreateFromHex("#ff9000") * 0.4f).ToVector3());
graphicsDevice.SetVertexBuffer(Mesh.VertexBuffer);
graphicsDevice.Indices = Mesh.IndexBuffer;
uniShader.CurrentTechnique.Passes[0].Apply();
graphicsDevice.DrawIndexedPrimitives(PrimitiveType.TriangleList, 0, 0, Mesh.TotalTriangles);
}
public ColorAutoComplete(bool includeDefaultColors)
{
Resources.UnloadUnusedAssets();
if (includeDefaultColors)
{
AddValue("Black", Color.black);
AddValue("White", Color.white);
AddValue("Cadet Blue", ColorExt.HTMLColor("#5F9EA0"));
AddValue("Saddle Brown", ColorExt.HTMLColor("#8B4513"));
AddValue("Teal Cyan", ColorExt.HTMLColor("#008080"));
AddValue("Spring Green", ColorExt.HTMLColor("#00FF7F"));
AddValue("Indian Red", ColorExt.HTMLColor("#CD5C5C"));
AddValue("Coral Orange", ColorExt.HTMLColor("#FF7F50"));
AddValue("Plum Purple", ColorExt.HTMLColor("#DDA0DD"));
AddValue("Dim Gray", ColorExt.HTMLColor("#696969"));
AddValue("Dark Gray", ColorExt.HTMLColor("#A9A9A9"));
AddValue("Silver Gray", ColorExt.HTMLColor("#C0C0C0"));
AddValue("Beige", ColorExt.HTMLColor("#F5F5DC"));
AddValue("Ivory White", ColorExt.HTMLColor("#FFFFF0"));
AddValue("Azure White", ColorExt.HTMLColor("#F0FFFF"));
AddValue("Blue", Color.blue);
AddValue("Light Blue", ColorExt.HTMLColor("#ADD8E6"));
AddValue("Navy Blue", ColorExt.HTMLColor("#000080"));
AddValue("Indigo Purple", ColorExt.HTMLColor("#4B0082"));
AddValue("Royal Blue", ColorExt.HTMLColor("#4169E1"));
AddValue("Maroon Brown", ColorExt.HTMLColor("#800000"));
AddValue("Chocolate Brown", ColorExt.HTMLColor("#D2691E"));
AddValue("Clear", Color.clear);
AddValue("Cyan", Color.cyan);
AddValue("Aquamarine Cyan", ColorExt.HTMLColor("#7FFFD4"));
AddValue("Turquoise Cyan", ColorExt.HTMLColor("#40E0D0"));
AddValue("Gray", Color.gray);
AddValue("Green", Color.green);
AddValue("Forest Green", ColorExt.HTMLColor("#228B22"));
AddValue("Light Green", ColorExt.HTMLColor("#90EE90"));
AddValue("Sea Green", ColorExt.HTMLColor("#2E8B57"));
AddValue("Olive Green", ColorExt.HTMLColor("#808000"));
AddValue("Grey", Color.grey);
AddValue("Magenta", Color.magenta);
AddValue("Red", Color.red);
AddValue("Salmon Red", ColorExt.HTMLColor("#FA8072"));
AddValue("Crimson Red", ColorExt.HTMLColor("#DC143C"));
AddValue("Brick Red", ColorExt.HTMLColor("#B22222"));
AddValue("Yellow", Color.yellow);
AddValue("Khaki Yellow", ColorExt.HTMLColor("#F0E68C"));
AddValue("Light Yellow", ColorExt.HTMLColor("#FFFF99"));
AddValue("Dark Yellow", ColorExt.HTMLColor("#666600"));
AddValue("Orange", ColorExt.HTMLColor("#FFA500"));
AddValue("Tomato Orange", ColorExt.HTMLColor("#FF6347"));
AddValue("Gold Yellow", ColorExt.HTMLColor("#FFD700"));
AddValue("Dark Orange", ColorExt.HTMLColor("#FF8C00"));
AddValue("Pink", ColorExt.HTMLColor("#FFC0CB"));
AddValue("Hot Pink", ColorExt.HTMLColor("#FF69B4"));
AddValue("Deep Pink", ColorExt.HTMLColor("#FF1493"));
AddValue("Violet Purple", ColorExt.HTMLColor("#EE82EE"));
AddValue("Medium Purple", ColorExt.HTMLColor("#9370DB"));
}
}
/// <summary>
/// Called to draw the background, before clipping is applied (if enabled). Default implementation draws the background drawable.
/// </summary>
/// <param name="batcher">Batcher.</param>
/// <param name="parentAlpha">Parent alpha.</param>
/// <param name="x">The x coordinate.</param>
/// <param name="y">The y coordinate.</param>
protected void DrawBackground(Batcher batcher, float parentAlpha, float x, float y)
{
if (_background == null)
{
return;
}
_background.Draw(batcher, x, y, GetWidth(), GetHeight(), ColorExt.Create(color, (int)(color.A * parentAlpha)));
}
public static Texture getBumpMap(Tile[,] tiles)
{
int width = tiles.GetLength(0);
int height = tiles.GetLength(1);
var texture = new Texture(width, height);
var pixels = new Color4[width, height];
for (var x = 0; x < width; x++)
{
for (var y = 0; y < height; y++)
{
switch (tiles[x, y].myHeightType)
{
case HeightType.DeepWater:
pixels[x, y] = new Color4(0, 0, 0, 1);
break;
case HeightType.ShallowWater:
pixels[x, y] = new Color4(0, 0, 0, 1);
break;
case HeightType.Sand:
pixels[x, y] = new Color4(0.3f, 0.3f, 0.3f, 1);
break;
case HeightType.Grass:
pixels[x, y] = new Color4(0.45f, 0.45f, 0.45f, 1);
break;
case HeightType.Forest:
pixels[x, y] = new Color4(0.6f, 0.6f, 0.6f, 1);
break;
case HeightType.Rock:
pixels[x, y] = new Color4(0.75f, 0.75f, 0.75f, 1);
break;
case HeightType.Snow:
pixels[x, y] = new Color4(1, 1, 1, 1);
break;
case HeightType.River:
pixels[x, y] = new Color4(0, 0, 0, 1);
break;
}
if (!tiles[x, y].myIsLand)
{
pixels[x, y] = ColorExt.mix(Color4.White, Color4.Black, tiles[x, y].myHeightValue * 2);
}
}
}
texture.setPixels(ref pixels);
return(texture);
}
public AppColorList()
{
Add(new AppColor(ColorExt.ToColorFromHex("#5BF5C2"), ColorExt.ToColorFromHex("#2D7A61"))); // light-green
Add(new AppColor(ColorExt.ToColorFromHex("#F55B5B"), ColorExt.ToColorFromHex("#7A2D2D"))); // red-dark
Add(new AppColor(ColorExt.ToColorFromHex("#C25BF5"), ColorExt.ToColorFromHex("#612D7A"))); // violet-blue
Add(new AppColor(ColorExt.ToColorFromHex("#C2F55B"), ColorExt.ToColorFromHex("#617A2D"))); // yell-green
Add(new AppColor(ColorExt.ToColorFromHex("#5B5BF5"), ColorExt.ToColorFromHex("#2D2D7A"))); // dark-blue
Add(new AppColor(ColorExt.ToColorFromHex("#5BC2F5"), ColorExt.ToColorFromHex("#2D617A"))); // light-blue
Add(new AppColor(ColorExt.ToColorFromHex("#5BF55B"), ColorExt.ToColorFromHex("#2D7A2D"))); // green-light
}
public override void Draw(Batcher batcher, float parentAlpha)
{
Validate();
var color = ColorExt.Create(this.color, (int)(this.color.A * parentAlpha));
_style.Background?.Draw(batcher, x, y, width == 0 ? _prefSize.X : width, height, color);
batcher.DrawString(_style.Font, _wrappedString, new Vector2(x, y) + _textPosition,
_style.FontColor, 0, Vector2.Zero, new Vector2(_fontScaleX, _fontScaleY), SpriteEffects.None, 0);
}
public static Color ParseColor(XAttribute xColor)
{
if (xColor == null)
{
return(Color.White);
}
var colorStr = ((string)xColor).TrimStart("#".ToCharArray());
return(ColorExt.HexToColor(colorStr));
}
public override void Draw(GdxSpriteBatch spriteBatch, float x, float y, float width, float height)
{
Sprite.SetBounds(x, y, width, height);
Color color = Sprite.Color;
Sprite.Color = ColorExt.Multiply(color, spriteBatch.Color);
Sprite.Draw(spriteBatch);
Sprite.Color = color;
}
void UpdateFontColor()
{
hue = hue + Random.Range(0.5f, 4f);
saturation = saturation + Random.Range(0.0035f, 0.005f);
hue = hue % 256;
saturation = Mathf.Max((saturation % 1.0f), 0.3f);
fontColor = ColorExt.ColorFromHSV(hue, saturation, 0.35f, 1);
text.color = fontColor;
}
public float Color_ConstructorArgOneByte()
{
float sum = 0;
for (int i = 0; i < data.Length; i++)
{
// ----- Test
data[i] = new ColorExt(1);
// ----- End Test
sum += data[i].R;
}
return(sum);
}
public void Draw(GdxSpriteBatch spriteBatch, float x, float y, float width, float height)
{
float centerColX = x + LeftWidth;
float rightColX = x + width - RightWidth;
float middleRowY = y + BottomHeight;
float topRowY = y + height - TopHeight;
Color color = ColorExt.Multiply(Color, spriteBatch.Color);
color = Color.FromNonPremultiplied(color.R, color.G, color.B, color.A);
if (_bottomLeft != -1)
{
Set(_bottomLeft, x, y, centerColX - x, middleRowY - y, color);
}
if (_bottomCenter != -1)
{
Set(_bottomCenter, centerColX, y, rightColX - centerColX, middleRowY - y, color);
}
if (_bottomRight != -1)
{
Set(_bottomRight, rightColX, y, x + width - rightColX, middleRowY - y, color);
}
if (_middleLeft != -1)
{
Set(_middleLeft, x, middleRowY, centerColX - x, topRowY - middleRowY, color);
}
if (_middleCenter != -1)
{
Set(_middleCenter, centerColX, middleRowY, rightColX - centerColX, topRowY - middleRowY, color);
}
if (_middleRight != -1)
{
Set(_middleRight, rightColX, middleRowY, x + width - rightColX, topRowY - middleRowY, color);
}
if (_topLeft != -1)
{
Set(_topLeft, x, topRowY, centerColX - x, y + height - topRowY, color);
}
if (_topCenter != -1)
{
Set(_topCenter, centerColX, topRowY, rightColX - centerColX, y + height - topRowY, color);
}
if (_topRight != -1)
{
Set(_topRight, rightColX, topRowY, x + width - rightColX, y + height - topRowY, color);
}
spriteBatch.Draw(Texture, _vertices, 0, _index);
}
public static Texture getHeatMapTexture(Tile[,] tiles)
{
int width = tiles.GetLength(0);
int height = tiles.GetLength(1);
var texture = new Texture(width, height);
var pixels = new Color4[width, height];
for (var x = 0; x < width; x++)
{
for (var y = 0; y < height; y++)
{
switch (tiles[x, y].myHeatType)
{
case HeatType.Coldest:
pixels[x, y] = Coldest;
break;
case HeatType.Colder:
pixels[x, y] = Colder;
break;
case HeatType.Cold:
pixels[x, y] = Cold;
break;
case HeatType.Warm:
pixels[x, y] = Warm;
break;
case HeatType.Warmer:
pixels[x, y] = Warmer;
break;
case HeatType.Warmest:
pixels[x, y] = Warmest;
break;
}
//darken the Color4 if a edge tile
if ((int)tiles[x, y].myHeightType > 2 && tiles[x, y].myBitmask != 15)
{
pixels[x, y] = ColorExt.mix(pixels[x, y], Color4.Black, 0.4f);
}
}
}
texture.setPixels(ref pixels);
return(texture);
}
private HexagonType GetHexagonType()
{
Color avg = GetAverageColor(OCRCenter, OCRRadius, OCRImage, BoundingBox);
double[] distance = COLOR_CELLS.Select(p => ColorExt.GetColorDistance(p.R, p.G, p.B, avg)).ToArray();
double min_distance = distance.Min();
if (min_distance >= MAX_TYPE_COLOR_DISTANCE)
{
return(HexagonType.UNKNOWN);
}
return((HexagonType)Enum.GetValues(typeof(HexagonType)).GetValue(distance.ToList().IndexOf(min_distance)));
}
private static void TryLog(string message, Color c, PUI_GameEventLog gameLog)
{
if (gameLog == null || !gameLog.gameObject.activeSelf)
{
return;
}
foreach (string item in message.Split(Environment.NewLine.ToCharArray()))
{
if (item.Trim().Length < 1)
{
continue;
}
gameLog.AddLogItem("<color=#" + ColorExt.ToHex(c) + "> > " + "DiffTweaker" + "</color>: " + item, eGameEventChatLogType.IncomingChat);
}
}
public bool update()
{
_elapsedTime += Time.deltaTime;
// fading block
if (_elapsedTime > _fadeDelay && _elapsedTime < _fadeDuration + _fadeDelay)
{
var t = Mathf.map01(_elapsedTime, 0f, _fadeDelay + _fadeDuration);
ColorExt.lerp(ref _initialColor, ref _targetColor, out _renderColor, t);
}
else if (_elapsedTime >= _fadeDuration + _fadeDelay)
{
return(true);
}
return(false);
}
public Bitmap GetProcessedImage(bool useTransparency, out int activePixel)
{
Bitmap img = OCRImage.Clone(BoundingBox, PixelFormat.Format32bppArgb);
activePixel = 0;
BitmapData srcData = img.LockBits(new Rectangle(0, 0, img.Width, img.Height), ImageLockMode.ReadWrite, PixelFormat.Format32bppArgb);
IntPtr Scan0 = srcData.Scan0;
int stride = srcData.Stride;
unsafe
{
byte *p = (byte *)(void *)Scan0;
for (int x = 0; x < img.Width; x++)
{
for (int y = 0; y < img.Height; y++)
{
int idx = (y * stride) + x * 4;
double s_value = ColorExt.GetSaturation(p[idx + 2], p[idx + 1], p[idx + 0]);
byte bval = (byte)(255 - (p[idx + 2] + p[idx + 1] + p[idx + 0]) / 3);
if (s_value >= 80)
{
p[idx + 0] = 255;
p[idx + 1] = 255;
p[idx + 2] = 255;
p[idx + 3] = (byte)(useTransparency ? 0 : 255);
}
else
{
activePixel++;
p[idx + 0] = bval;
p[idx + 1] = bval;
p[idx + 2] = bval;
p[idx + 3] = 255;
}
}
}
}
img.UnlockBits(srcData);
return(img);
}
public override void DisplayError(SourceMap sourceMap)
{
if (_trace.Any())
{
_trace.RemoveAt(_trace.Count - 1);
_trace.Reverse();
_trace.RemoveAt(_trace.Count - 1);
foreach (Span trace in _trace)
{
FormatEntry(trace, sourceMap, ColorExt.Surround("trace", Color.Red));
}
}
string newErrMsg = ColorExt.Surround(_errorMsg, Color.Bold);
string errName = ColorExt.Surround($"{_type.Name()}_error", Color.Bold, Color.Red);
FormatEntry(_errorSpan, sourceMap, $"{errName}: {newErrMsg}");
}
Dictionary <string, Color> parseColors(JObject colors)
{
if (colors.Count == 0)
{
return(null);
}
var result = new Dictionary <string, Color>(colors.Count);
foreach (JProperty key in colors.Children())
{
var obj = colors[key.Name];
UISkinImporter.logger.LogMessage("adding color: {0}", key.Name);
if (obj is JValue)
{
var jVal = obj as JValue;
var val = jVal.Value as string;
// we could have hex or hex
if (val.StartsWith("#"))
{
result.Add(key.Name, ColorExt.hexToColor(val.Substring(1)));
}
else if (val.StartsWith("0x"))
{
result.Add(key.Name, ColorExt.hexToColor(val.Substring(2)));
}
else
{
UISkinImporter.logger.LogMessage("unsupported color definition {0}: {1}", key.Name, val);
}
}
else if (obj is JArray)
{
var jArr = obj as JArray;
var arr = jArr.ToObject <int[]>();
result.Add(key.Name, new Color(arr[0], arr[1], arr[2], arr[3]));
}
}
UISkinImporter.logger.LogMessage("");
return(result);
}
public static Color FromString(string color)
{
switch (color)
{
case ("WHITE"):
return(Color.white);
case ("ALABASTER_RED"):
return(ColorExt.Hex("C4302B"));
case ("RED"):
return(ColorExt.RedBright(1f));
case ("GREEN"):
return(ColorExt.GreenBright(1f));
case ("BLUE"):
return(Color.blue);
case ("CYAN"):
return(Color.cyan);
case ("YELLOW"):
return(Color.yellow);
case ("PINK"):
return(ColorExt.Pink(1f));
case ("MAGENTA"):
return(Color.magenta);
case ("ORANGE"):
return(ColorExt.OrangeBright(1f));
case ("BLACK"):
return(Color.black);
default:
return(Color.white);
}
}
public override void Draw(Batcher batcher, float parentAlpha)
{
Validate();
if (transform)
{
ApplyTransform(batcher, ComputeTransform());
}
if (_firstWidget != null && _firstWidget.IsVisible())
{
var scissor = ScissorStack.CalculateScissors(_stage?.Camera, batcher.TransformMatrix, _firstWidgetBounds);
if (ScissorStack.PushScissors(scissor))
{
batcher.EnableScissorTest(true);
_firstWidget.Draw(batcher, parentAlpha * color.A);
batcher.EnableScissorTest(false);
ScissorStack.PopScissors();
}
}
if (_secondWidget != null && _secondWidget.IsVisible())
{
var scissor = ScissorStack.CalculateScissors(_stage?.Camera, batcher.TransformMatrix,
_secondWidgetBounds);
if (ScissorStack.PushScissors(scissor))
{
batcher.EnableScissorTest(true);
_secondWidget.Draw(batcher, parentAlpha * color.A);
batcher.EnableScissorTest(false);
ScissorStack.PopScissors();
}
}
_style.Handle.Draw(batcher, _handleBounds.X, _handleBounds.Y, _handleBounds.Width, _handleBounds.Height,
ColorExt.Create(color, (int)(color.A * parentAlpha)));
if (transform)
{
ResetTransform(batcher);
}
}
private static string UpdateUILabelByConfig(UILabel uiConfigLabel, ClientUIFontDto ClientUIFontDto)
{
if (null == uiConfigLabel || null == ClientUIFontDto)
{
return(null);
}
uiConfigLabel.fontSize = ClientUIFontDto.fontSize;
uiConfigLabel.bitmapFont = FontManager.GetFontNoNull(ClientUIFontDto.fontName);
uiConfigLabel.fontStyle = (FontStyle)ClientUIFontDto.fontStyle;
uiConfigLabel.applyGradient = ClientUIFontDto.gradient;
uiConfigLabel.gradientTop = ColorExt.HexStrToColor(ClientUIFontDto.gradientTop);
uiConfigLabel.gradientBottom = ColorExt.HexStrToColor(ClientUIFontDto.gradientBottom);
uiConfigLabel.effectStyle = (UILabel.Effect)ClientUIFontDto.effect;
uiConfigLabel.effectColor = ColorExt.HexStrToColor(ClientUIFontDto.effectColor.ToString());
uiConfigLabel.effectDistance = new Vector2(ClientUIFontDto.effectX, ClientUIFontDto.effectY);
uiConfigLabel.floatSpacingX = ClientUIFontDto.spacingX;
uiConfigLabel.floatSpacingY = ClientUIFontDto.spacingY;
uiConfigLabel.spacingX = ClientUIFontDto.spacingX;
uiConfigLabel.spacingY = ClientUIFontDto.spacingY;
uiConfigLabel.color = ColorExt.HexStrToColor(ClientUIFontDto.colorTint);
return(ClientUIFontDto.shortDesc);
}
public bool update()
{
// update values
_timeToLive -= Time.deltaTime;
if (_timeToLive > 0)
{
// TODO: update kinematics
position += velocity * Time.deltaTime;
// interpolate values
ColorExt.lerp(ref _startColor, ref _endColor, out color, (_lifetime - _timeToLive) / (_lifetime));
scale += _scaleDelta * Time.deltaTime;
alpha += _alphaDelta * Time.deltaTime;
color.A = (byte)(255 * alpha);
}
else
{
return(true);
}
return(false);
}
public static Texture getSimpleHeatMapTexture(Tile[,] tiles)
{
int width = tiles.GetLength(0);
int height = tiles.GetLength(1);
var texture = new Texture(width, height);
var pixels = new Color4[width, height];
for (var x = 0; x < width; x++)
{
for (var y = 0; y < height; y++)
{
pixels[x, y] = ColorExt.mix(Color4.Blue, Color4.Red, tiles[x, y].myHeatValue);
//darken the color if a edge tile
if (tiles[x, y].myBitmask != 15)
{
pixels[x, y] = ColorExt.mix(pixels[x, y], Color4.Black, 0.4f);
}
}
}
texture.setPixels(ref pixels);
return(texture);
}
private static void InitGraphics(GettingStartedPanel panel)
{
MonkeyStyle.Instance.PostInstanceCreation();
panel.monKeyBanner = MonkeyStyle.Instance.GetTextureFromName("MonKeyBanner");
panel.monKeyBannerStyle = new GUIStyle()
{
fixedWidth = 601,
fixedHeight = 260,
normal = { background = panel.monKeyBanner }
};
panel.welcomeTitleStyle = new GUIStyle()
{
fontSize = 28,
stretchWidth = true,
alignment = TextAnchor.MiddleCenter,
padding = new RectOffset(10, 10, 10, 5),
normal = { background = MonkeyStyle.Instance.WindowBackgroundTex }
};
panel.rateUsSectionStyle = new GUIStyle(panel.welcomeTitleStyle)
{
padding = new RectOffset(15, 10, 10, 5),
normal = { background = MonkeyStyle.Instance.TopPanelGradientTexture }
};
panel.sectionTitleStyle = new GUIStyle()
{
fontSize = 20,
stretchWidth = true,
alignment = TextAnchor.MiddleLeft,
padding = new RectOffset(5, 5, 5, 0),
margin = new RectOffset(30, 0, 0, 0)
};
panel.welcomeTextStyle = new GUIStyle(MonkeyStyle.Instance.CommandNameStyle)
{
fontSize = 12,
stretchWidth = true,
alignment = TextAnchor.MiddleCenter,
padding = new RectOffset(5, 5, 5, 5),
// normal = { background = MonkeyStyle.Instance.SelectedResultFieldTex }
};
panel.sectionSubtitleStyle = new GUIStyle(panel.welcomeTextStyle)
{
alignment = TextAnchor.MiddleLeft,
margin = new RectOffset(30, 0, 0, 0)
};
panel.sectionBackgroundStyle = new GUIStyle()
{
normal = { background = MonkeyStyle.ColorTexture(1, 1, ColorExt.HTMLColor("3a3a3a")) }
};
panel.titleColor = ColorExt.HTMLColor("cbcbcb");
panel.sectionSubtitleColor = ColorExt.HTMLColor("ae8d4d");
panel.buttonStyle = new GUIStyle()
{
fixedHeight = 50,
fixedWidth = 250,
fontSize = 12,
alignment = TextAnchor.MiddleCenter,
normal = { background = MonkeyStyle.ColorTexture(1, 1, ColorExt.HTMLColor("4d4d4d")) },
hover = { background = MonkeyStyle.ColorTexture(1, 1,
ColorExt.HTMLColor("4d4d4d").DarkerBrighter(-.1f)) },
};
panel.newVersionButtonStyle = new GUIStyle()
{
fixedHeight = 30,
stretchWidth = true,
fontSize = 12,
alignment = TextAnchor.MiddleCenter,
normal = { background = MonkeyStyle.ColorTexture(1, 1, ColorExt.HTMLColor("4d4d4d")) },
hover = { background = MonkeyStyle.ColorTexture(1, 1,
ColorExt.HTMLColor("4d4d4d").DarkerBrighter(-.05f)) },
};
panel.rateUsButtonBoxStyle = new GUIStyle()
{
margin = new RectOffset(1, 1, 1, 1),
stretchWidth = true,
};
panel.newVersionButtonBoxStyle = new GUIStyle()
{
margin = new RectOffset(1, 1, 1, 1),
padding = new RectOffset(5, 5, 0, 0),
stretchWidth = true,
};
panel.buttonTop = new GUIStyle()
{
fixedHeight = 2,
stretchWidth = true,
normal = { background = MonkeyStyle.ColorTexture(1, 1, ColorExt.HTMLColor("616161")) },
hover = { background = MonkeyStyle.ColorTexture(1, 1,
ColorExt.HTMLColor("616161").DarkerBrighter(-.1f)) }
};
panel.buttonBottom = new GUIStyle()
{
fixedHeight = 2,
stretchWidth = true,
normal = { background = MonkeyStyle.ColorTexture(1, 1, ColorExt.HTMLColor("2d2d2d")) },
hover = { background = MonkeyStyle.ColorTexture(1, 1,
ColorExt.HTMLColor("2d2d2d").DarkerBrighter(-.1f)) }
};
panel.buttonHighlightStyle = new GUIStyle()
{
margin = new RectOffset(10, 10, 10, 10),
normal =
{
background = MonkeyStyle.ColorTexture(1, 1, ColorExt.HTMLColor("8FC225"))
}
};
}
public override void Draw(Batcher batcher, float parentAlpha)
{
Validate();
IDrawable background;
if (_isDisabled && style.BackgroundDisabled != null)
{
background = style.BackgroundDisabled;
}
else if (_selectBoxList.HasParent() && style.BackgroundOpen != null)
{
background = style.BackgroundOpen;
}
else if (_isMouseOver && style.BackgroundOver != null)
{
background = style.BackgroundOver;
}
else if (style.Background != null)
{
background = style.Background;
}
else
{
background = null;
}
var font = style.Font;
var fontColor = _isDisabled ? style.DisabledFontColor : style.FontColor;
var color = GetColor();
color = ColorExt.Create(color, (int)(color.A * parentAlpha));
float x = GetX();
float y = GetY();
float width = GetWidth();
float height = GetHeight();
if (background != null)
{
background.Draw(batcher, x, y, width, height, color);
}
var selected = _selection.First();
if (selected != null)
{
var str = selected.ToString();
if (background != null)
{
width -= background.LeftWidth + background.RightWidth;
height -= background.BottomHeight + background.TopHeight;
x += background.LeftWidth;
y += (int)(height / 2 + background.BottomHeight - font.LineHeight / 2);
}
else
{
y += (int)(height / 2 + font.LineHeight / 2);
}
fontColor = ColorExt.Create(fontColor, (int)(fontColor.A * parentAlpha));
batcher.DrawString(font, str, new Vector2(x, y), fontColor);
}
}
