public void ChangeSprite(Sprites TheSprite)
{
CurrentSprite = TheSprite;
switch (CurrentSprite)
{
case Sprites.Locked:
TheCrosshair.sprite = LockedSprite;
break;
case Sprites.Push:
TheCrosshair.sprite = PushSprite;
break;
case Sprites.Neutral:
TheCrosshair.sprite = NeutralSprite;
break;
case Sprites.Grab:
TheCrosshair.sprite = GrabSprite;
break;
case Sprites.Safe:
TheCrosshair.sprite = SafeSprite;
break;
case Sprites.Padlock:
TheCrosshair.sprite = PadlockSprite;
break;
case Sprites.View:
TheCrosshair.sprite = ViewSprite;
break;
case Sprites.Gear:
TheCrosshair.sprite = GearSprite;
break;
default:
break;
}
}
public static Sprite GetSprite(Sprites sprite)
{
if (All.ContainsKey(sprite)) {
return All[sprite];
} else {
return null;
}
}
public static Texture2D GetTexture(Sprites sprite)
{
Texture2D texture;
if (!_textureCache.TryGetValue(sprite, out texture)) {
Logger.Error(TAG, String.Format("Unable to fetch sprite \"{0}\"", sprite));
}
return texture;
}
// Use this for initialization
void Start()
{
spriteScript = GameObject.Find("SpritesHolder").GetComponent<Sprites>();
GameObject childSprite = this.transform.GetChild(0).gameObject;
SpriteRenderer tile = childSprite.GetComponent<SpriteRenderer>();
tile.sprite = spriteScript.GetTileSprite();
int rndRot = Random.Range(0, 4);
if(rndRot == 0)
childSprite.transform.rotation = Quaternion.Euler(0, 0, 0);
if(rndRot == 1)
childSprite.transform.rotation = Quaternion.Euler(0, 0, 90);
if(rndRot == 2)
childSprite.transform.rotation = Quaternion.Euler(0, 0, 180);
if(rndRot == 3)
childSprite.transform.rotation = Quaternion.Euler(0, 0, 270);
}
public void DrawLight(RenderTexture renderTexture, double x, double y, double radius)
{
Sprite sprite;
if (radius < 401)
{
sprite = Sprites.Light(LightSprite.Light200x200);
sprite.Scale = new Vector2f((float)(radius / 200f), (float)(radius / 200f));
}
else if (radius < 601)
{
sprite = Sprites.Light(LightSprite.Light300x300);
sprite.Scale = new Vector2f((float)(radius / 300f), (float)(radius / 300f));
}
else
{
sprite = Sprites.Light(LightSprite.Light400x400);
sprite.Scale = new Vector2f((float)(radius / 400f), (float)(radius / 400f));
}
DrawGameUnitSprite(sprite, x, y, null, renderTexture, sprite.Scale, new RenderStates(BlendMode.Add));
}
public Sequence(CacheBase Cache, int Address)
{
EndianReader Reader = Cache.Reader;
Reader.SeekTo(Address);
Name = Reader.ReadNullTerminatedString(32);
FirstSubmapIndex = Reader.ReadInt16();
BitmapCount = Reader.ReadInt16();
#region Sprite Chunk
Reader.SeekTo(Address + 52);
int iCount = Reader.ReadInt32();
int iOffset = Reader.ReadInt32() - Cache.Magic;
for (int i = 0; i < iCount; i++)
{
Sprites.Add(new Sprite(Cache, iOffset + 32 * i));
}
Reader.SeekTo(Address + 64);
#endregion
}
public async Task Sprite([Remainder] string name = "")
{
var embed = new EmbedBuilder();
embed.WithColor(Colors.Get("Iodem"));
if (Sprites.GetSpriteCount() == 0)
{
embed.WithDescription(Utilities.GetAlert("no_sprites"));
}
else if (name == "")
{
embed.WithImageUrl(Sprites.GetRandomSprite());
}
else
{
embed.WithImageUrl(Sprites.GetImageFromName(name));
}
await Context.Channel.SendMessageAsync("", false, embed.Build());
}
internal void UpdatePips()
{
foreach (GameObject p in pipObjects)
{
Destroy(p);
}
pipObjects.Clear();
int pipGap = (int)((Sprites.GetBounds(Sprites.ability_border).x - 2 - Sprites.GetBounds(Sprites.ability_pip).x *pips) / (pips + 1));
int currentX = 2 + pipGap;
for (int i = 0; i < pips; i++)
{
GameObject pip = Primitives.CreateActor(Sprites.ability_pip, currentX, 2);
pipObjects.Add(pip);
Util.SetLayer(pip, Util.LayerName.UI, 0);
currentX += (int)(Sprites.GetBounds(Sprites.ability_pip).x);
currentX += pipGap;
pip.transform.SetParent(transform, false);
pip.name = "pip";
}
}
public void AddDefaultPlaylists()
{
Logger.Log("Creating default playlists...");
List <BeatmapLevelSO> levels = _levelCollection.GetPrivateField <BeatmapLevelSO[]>("_beatmapLevels").ToList();
Playlist _allPlaylist = new Playlist()
{
playlistTitle = "All songs", playlistAuthor = "", image = Sprites.SpriteToBase64(Sprites.BeastSaberLogo), icon = Sprites.BeastSaberLogo, fileLoc = ""
};
_allPlaylist.songs = new List <PlaylistSong>();
_allPlaylist.songs.AddRange(levels.Select(x => new PlaylistSong()
{
songName = $"{x.songName} {x.songSubName}", level = x, oneSaber = x.beatmapCharacteristics.Any(y => y.characteristicName == "One Saber"), path = "", key = "", levelId = x.levelID, hash = CustomHelpers.CheckHex(x.levelID.Substring(0, Math.Min(32, x.levelID.Length)))
}));
Logger.Log($"Created \"{_allPlaylist.playlistTitle}\" playlist with {_allPlaylist.songs.Count} songs!");
Playlist _favPlaylist = new Playlist()
{
playlistTitle = "Your favorite songs", playlistAuthor = "", image = Sprites.SpriteToBase64(Sprites.BeastSaberLogo), icon = Sprites.BeastSaberLogo, fileLoc = ""
};
_favPlaylist.songs = new List <PlaylistSong>();
_favPlaylist.songs.AddRange(levels.Where(x => PluginConfig.favoriteSongs.Contains(x.levelID)).Select(x => new PlaylistSong()
{
songName = $"{x.songName} {x.songSubName}", level = x, oneSaber = x.beatmapCharacteristics.Any(y => y.characteristicName == "One Saber"), path = "", key = "", levelId = x.levelID, hash = CustomHelpers.CheckHex(x.levelID.Substring(0, Math.Min(32, x.levelID.Length)))
}));
Logger.Log($"Created \"{_favPlaylist.playlistTitle}\" playlist with {_favPlaylist.songs.Count} songs!");
if (PlaylistsCollection.loadedPlaylists.Any(x => x.playlistTitle == "All songs" || x.playlistTitle == "Your favorite songs"))
{
PlaylistsCollection.loadedPlaylists.RemoveAll(x => x.playlistTitle == "All songs" || x.playlistTitle == "Your favorite songs");
}
PlaylistsCollection.loadedPlaylists.Insert(0, _favPlaylist);
PlaylistsCollection.loadedPlaylists.Insert(0, _allPlaylist);
_favPlaylist.SavePlaylist("Playlists\\favorites.json");
}
/// <summary>
/// Draws the menu.
/// </summary>
public override void Draw(GameTime gameTime)
{
Vector2 transitionOffset = new Vector2(0f, (float)Math.Pow(TransitionPosition, 2) * 90f);
// Draw each menu entry in turn.
Quads.Begin();
foreach (MenuEntry entry in _menuEntries)
{
Quads.Render(entry.Position - _menuEntrySize / 2f, entry.Position + _menuEntrySize / 2f, null, true,
ContentWrapper.Grey * entry.Alpha * TransitionAlpha, entry.TileColor * entry.Alpha * TransitionAlpha);
}
Quads.Render(_menuSlider.Position - new Vector2(_menuEntrySize.Y / 2f), _menuSlider.Position + new Vector2(_menuEntrySize.Y / 2f), null, true,
ContentWrapper.Grey * TransitionAlpha, _menuSlider.TileColor * TransitionAlpha);
Quads.End();
Sprites.Begin();
foreach (MenuEntry entry in _menuEntries)
{
Sprites.DrawString(_font, entry.Text, entry.Position + Vector2.One, ContentWrapper.Black * entry.Alpha * entry.Alpha * TransitionAlpha,
0f, entry.Origin, entry.Scale, SpriteEffects.None, 0f);
Sprites.DrawString(_font, entry.Text, entry.Position, entry.TextColor * entry.Alpha * TransitionAlpha,
0f, entry.Origin, entry.Scale, SpriteEffects.None, 0f);
if (entry.Fade > 0f)
{
Sprites.Draw(entry.Preview, PreviewPosition, null, Color.White * Math.Max((TransitionAlpha - 0.8f) / 0.2f, 0f) * entry.Fade, 0f, _previewOrigin, 1f, SpriteEffects.None, 0f);
}
}
Sprites.End();
Quads.Begin();
Quads.Render(Vector2.Zero, new Vector2(Framework.GraphicsDevice.Viewport.Width, TitleBarHeight), null, ContentWrapper.Grey * 0.7f * TransitionAlpha);
Quads.End();
// Make the menu slide into place during transitions, using a
// power curve to make things look more interesting (this makes
// the movement slow down as it nears the end).
Sprites.Begin();
Sprites.Draw(_samplesLogo, _titlePosition - transitionOffset, null, Color.White, 0f, _titleOrigin, 1f, SpriteEffects.None, 0f);
Sprites.End();
}
public void DrawMinionRespawn(Vector2f[] points, bool isUnion)
{
WayPointInfo[][] respawnWayPoints;
if (isUnion)
{
if (respawnUnionPoints == null)
{
respawnUnionPoints = points;
respawnWayPoints = respawnUnionWayPoints = GenerateWayPoints(points, 100);
}
else
{
respawnWayPoints = respawnUnionWayPoints;
}
}
else if (respawnEnemyPoints == null)
{
respawnEnemyPoints = points;
respawnWayPoints = respawnEnemyWayPoints = GenerateWayPoints(points, 100);
}
else
{
respawnWayPoints = respawnEnemyWayPoints;
}
for (int i = 0; i < respawnWayPoints.Length; i++)
{
var point = points[i];
var isVisiblePoint = visibleArea[(int)(point.X / visibleArea.Length)][(int)(point.Y / visibleArea.Length)] != 0;
if (!isVisiblePoint)
{
continue;
}
int n = (index / 1) % respawnWayPoints[i].Length;
var sprite = isUnion
? Sprites.Critter_Union(respawnWayPoints[i][n].Angle)
: Sprites.Critter_Enemy(respawnWayPoints[i][n].Angle);
DrawGameUnitSprite(sprite, respawnWayPoints[i][n].Point.X, respawnWayPoints[i][n].Point.Y);
}
}
public override void Draw(SpriteBatch spriteBatch)
{
base.Draw(spriteBatch);
RenderMap(spriteBatch);
RenderHUD(spriteBatch);
// Render Dialog
if (DialogEnabled)
{
MessageDialog.Draw(spriteBatch);
}
spriteBatch.Begin();
// Render Cursor
spriteBatch.Draw(Sprites.GetSprite("/cursor.png"), new Rectangle(CursorX, CursorY, 17, 23), Color.White);
spriteBatch.End();
}
public void Resume()
{
if (!isPause)
{
return;
}
isPause = false;
UpdateGoldText();
UpdateCashText();
UpdateTicketText();
UpdateHeadIcon();
#if UNITY_IOS
if (currentBottomButton == offerwallButton)
{
offerwallButton.image.sprite = Sprites.GetSprite(SpriteAtlas_Name.Menu, Save.data.isPackB ? "Offerwall_On" : "Task_On");
}
else
{
offerwallButton.image.sprite = Sprites.GetSprite(SpriteAtlas_Name.Menu, Save.data.isPackB ? "Offerwall_Off" : "Task_Off");
}
#endif
}
private SpriteCollection.TextureData[] _GetCurrentImageLayers()
{
List <SpriteCollection.TextureData> layers = new List <SpriteCollection.TextureData>();
Common.State state = BaseItem.state;
Common.Direction direction = BaseItem.direction;
List <int> spriteIds = BaseItem.itemData.GetSprites(state);
if (spriteIds == null || spriteIds.Count == 0)
{
return(null);
}
for (int index = 0; index < spriteIds.Count; index++)
{
SpriteCollection.SpriteData sprite = Sprites.GetSprite(spriteIds[index]);
layers.Add(sprite.GetTextureData(direction));
}
return(layers.ToArray());
}
public Heros()
{
this.Position = new int[] { 1, 5 };
Profit = 0;
Argent = 100.0;
Sprites.Add(Properties.Resources.bas1); // 0
Sprites.Add(Properties.Resources.bas2); // 1
Sprites.Add(Properties.Resources.bas3); // 2
Sprites.Add(Properties.Resources.droite1); // 3
Sprites.Add(Properties.Resources.droite2); // 4
Sprites.Add(Properties.Resources.gauche1); // 5
Sprites.Add(Properties.Resources.gauche2); // 6
Sprites.Add(Properties.Resources.haut1); // 7
Sprites.Add(Properties.Resources.haut2); // 8
Sprites.Add(Properties.Resources.haut3); // 9
RotationSpriteBas = 0;
RotationSpriteDroite = 3;
RotationSpriteGauche = 5;
RotationSpriteHaut = 7;
}
protected override void OnSpriteCreated()
{
Context.Reset();
var lotterySprite = Sprites.FindFirst("LotterySprite");
lotterySprite.Hit += PersonWin;
var thunderSprite = Sprites.FindFirst("Thunder");
if (thunderSprite != null)
{
thunderSprite.Hit += PersonLost;
}
Sprites.QueryBehavior <ButtonBehavior>("StartButton")
.Click += (o, e) => TriggerStart();
if (Context.CurrentPrize != null)
{
CreatePersons();
}
}
void Awake()
{
m_Colors = Colors;
m_Game = Game;
m_Music = Music;
m_Particles = Particles;
m_Prefabs = Prefabs;
m_Sprites = Sprites;
m_Score = Score;
m_SoundFX = SoundFX;
m_Timer = Timer;
if (!MainMenu)
m_Camera = Camera;
m_Strings = TextStrings;
m_Input = InputHandler;
if (MainMenu)
m_interMain = MainMenu;
else if(HUD)
m_interGame = HUD;
else if (CreateMode)
m_interCreate = CreateMode;
}
protected virtual void OnWrappingChanged(bool oldHoriz, bool newHoriz, bool oldVerti, bool newVerti)
{
if (WrappingChanged != null)
{
GridPointMatrixWrappingChangedEventArgs e =
new GridPointMatrixWrappingChangedEventArgs(this, oldHoriz, newHoriz, oldVerti, newVerti);
WrappingChanged(e);
}
// set indexer delegate
if (newHoriz || newVerti)
{
FindIndexedGridPoint = new GetIndexer(GetIndexer_Wrap);
}
else
{
FindIndexedGridPoint = new GetIndexer(GetIndexer_NoWrap);
}
// create new child Sprites for all Sprite instances on this grid
Sprites.CreateChildSprites(this);
}
public async Task Status([Remainder] SocketUser user = null)
{
user ??= Context.User;
var account = EntityConverter.ConvertUser(user);
var factory = new PlayerFighterFactory();
var p = factory.CreatePlayerFighter(account);
var author = new EmbedAuthorBuilder();
author.WithName($"{(user is SocketGuildUser sguser ? sguser.DisplayName() : user.Username)}");
author.WithIconUrl(user.GetAvatarUrl());
var embed = new EmbedBuilder()
.WithColor(Colors.Get(account.Element.ToString()))
.WithAuthor(author)
.WithTitle($"Level {account.LevelNumber} {account.GsClass} {string.Join("", account.TrophyCase.Trophies.Select(t => t.Icon))} (Rank {UserAccounts.GetRank(account) + 1})")
.AddField("Current Equip", account.Inv.GearToString(AdeptClassSeriesManager.GetClassSeries(account).Archtype), true)
.AddField("Psynergy", p.GetMoves(false), true)
.AddField("Djinn", account.DjinnPocket.GetDjinns().GetDisplay(DjinnDetail.None), true)
.AddField("Stats", p.Stats.ToString(), true)
.AddField("Elemental Stats", p.ElStats.ToString(), true)
.AddField("Unlocked Classes", account.BonusClasses.Count == 0 ? "none" : string.Join(", ", account.BonusClasses))
.AddField("XP", $"{account.XP} - next in {account.XPneeded}{(account.NewGames > 1 ? $"\n({account.TotalXP} total | {account.NewGames} resets)" : "")}", true)
.AddField("Colosso wins | Dungeon Wins", $"{account.ServerStats.ColossoWins} | {account.ServerStats.DungeonsCompleted}", true)
.AddField("Endless Streaks", $"Solo: {account.ServerStats.EndlessStreak.Solo} | Duo: {account.ServerStats.EndlessStreak.Duo} \nTrio: {account.ServerStats.EndlessStreak.Trio} | Quad: {account.ServerStats.EndlessStreak.Quad}", true);
if (user is SocketGuildUser socketGuildUser)
{
var Footer = new EmbedFooterBuilder();
Footer.WithText("Joined this Server on " + socketGuildUser.JoinedAt.Value.Date.ToString("dd-MM-yyyy"));
Footer.WithIconUrl(Sprites.GetImageFromName("Iodem"));
embed.WithFooter(Footer);
}
await Context.Channel.SendMessageAsync("", false, embed.Build());
}
public LevelObjectPrefab(XElement element, string identifier = null)
{
ChildObjects = new List <ChildObject>();
LevelTriggerElements = new List <XElement>();
OverrideProperties = new List <LevelObjectPrefab>();
OverrideCommonness = new Dictionary <string, float>();
Identifier = null;
SerializableProperties = SerializableProperty.DeserializeProperties(this, element);
if (element != null)
{
Config = element;
Identifier = element.GetAttributeString("identifier", null) ?? identifier;
if (string.IsNullOrEmpty(Identifier))
{
#if DEBUG
DebugConsole.ThrowError($"Level object prefab \"{element.Name}\" has no identifier! Using the name as the identifier instead...");
#else
DebugConsole.AddWarning($"Level object prefab \"{element.Name}\" has no identifier! Using the name as the identifier instead...");
#endif
Identifier = element.Name.ToString();
}
LoadElements(element, -1);
InitProjSpecific(element);
}
//use the maximum width of the sprite as the minimum surface width if no value is given
if (element != null && !element.Attributes("minsurfacewidth").Any())
{
if (Sprites.Any())
{
MinSurfaceWidth = Sprites[0].size.X * MaxSize;
}
if (DeformableSprite != null)
{
MinSurfaceWidth = Math.Max(MinSurfaceWidth, DeformableSprite.Size.X * MaxSize);
}
}
}
public void Init(bool isFree, int index)
{
this.index = index;
bgImage.sprite = Sprites.GetBGSprite("bg_" + index);
titleImage.sprite = Sprites.GetSprite(SpriteAtlas_Name.Slots, "title_" + index);
if (index == 3 || index == 6)
{
cashNum = isFree ? 150 : 500;
}
else
{
cashNum = isFree ? 50 : 200;
}
reward_numText.text = cashNum.ToString();
isAd = !isFree;
#if UNITY_ANDROID
ad_maskGo.SetActive(isAd);
#elif UNITY_IOS
ad_maskGo.SetActive(isAd && Save.data.isPackB);
#endif
reward_numText.transform.parent.gameObject.SetActive(!isAd);
}
public void LoadSheet(string fileName)
{
Bitmap image;
try {
image = new Bitmap(fileName);
} catch (Exception e) {
MessageBox.Show(e.Message, "Error loading image");
return;
}
string name = System.IO.Path.GetFileName(fileName);
int x = image.Width / 32;
int y = image.Height / 32;
for (int j = 0; j < y; j++)
{
for (int i = 0; i < x; i++)
{
string spriteName = name;
var cloneRect = new System.Drawing.Rectangle(i * 32, j * 32, 32, 32);
Bitmap cloneBitmap = image.Clone(cloneRect, image.PixelFormat);
if (_imageValidator.IsEmpty(cloneBitmap))
{
continue;
}
var imageSource =
System.Windows.Interop.Imaging.CreateBitmapSourceFromHBitmap(cloneBitmap.GetHbitmap(),
IntPtr.Zero, Int32Rect.Empty, BitmapSizeOptions.FromEmptyOptions());
Sprites.Add(new Sprite(spriteName, new Vector2(0, 0),
new Microsoft.Xna.Framework.Rectangle(cloneRect.X, cloneRect.Y, cloneRect.Width,
cloneRect.Height))
{
ImageSource = imageSource
});
}
}
}
private bool SaveSprites(string filename)
{
try
{
using (var fs = new FileStream(filename, FileMode.Create, FileAccess.Write))
{
using var w = new BinaryWriter(fs);
w.Write(Encoding.UTF8.GetBytes("SPRDEF"));
Sprites.WriteBytes(w);
w.Flush();
w.Close();
fs.Close();
}
Filename = filename;
Text = $@"SPRDEF - {Filename}";
return(true);
}
catch (Exception)
{
return(false);
}
}
public async Task Claim()
{
var account = UserAccounts.GetAccount(Context.User);
var inv = account.Inv;
if (DateTime.Now <= new DateTime(2019, 7, 1) && account.LastClaimed < new DateTime(2019, 6, 1))
{
var coins = account.LevelNumber * 120;
inv.AddBalance(coins);
var chest1 = (ChestQuality)Math.Max(0, Math.Min(4, ((int)account.LevelNumber / 11) - 1));
var chest2 = (ChestQuality)Math.Max(0, Math.Min(4, ((int)account.LevelNumber / 11 - 2)));
inv.AwardChest(chest1);
inv.AwardChest(chest2);
var embed = new EmbedBuilder();
embed.WithColor(Colors.Get("Iodem"));
embed.WithDescription($"Thank you for being part of this server! I hope you have fun with the new items. Here, take this: \n <:coin:569836987767324672>{coins}\n Also, take these to start off your journey: \n{Inventory.ChestIcons[chest2]} {Inventory.ChestIcons[chest1]} ");
embed.WithThumbnailUrl(Sprites.GetImageFromName("Iodem"));
account.LastClaimed = DateTime.Now;
await Context.Channel.SendMessageAsync("", false, embed.Build());
}
}
public override void Draw()
{
Sprites.Begin(0, null, null, null, null, null, Camera.View);
for (int i = 0; i < 5; ++i)
{
Sprites.Draw(_rectangleSprite.Image, ConvertUnits.ToDisplayUnits(_rectangle[i].Position), null,
Color.White, _rectangle[i].Rotation, _rectangleSprite.Origin, 1f, SpriteEffects.None, 0f);
}
Sprites.End();
Lines.Begin(ref Camera.SimProjection, ref Camera.SimView);
foreach (Fixture f in _ramps.FixtureList)
{
Lines.DrawLineShape(f.Shape, Colors.Teal);
}
Lines.End();
base.Draw();
}
public void RemoveSprite(string name)
{
Sprite sprite = GetSpriteByName(name);
if (sprite == null)
{
throw new ArgumentException("Sprite not found.");
}
for (int i = 0; i < ShotTypes.Count; i++)
{
ShotType shot_type = ShotTypes[i];
if (shot_type is StillShotType still)
{
if (still.Sprite == sprite)
{
RemoveShotType(still.Name);
i--;
}
}
else if (shot_type is AnimationShotType anim)
{
anim.RemoveSprite(sprite);
if (anim.Animation.Length == 0)
{
RemoveShotType(anim.Name);
i--;
}
}
}
Sprites.Remove(sprite);
if (DelaySprite == sprite)
{
DelaySprite = null;
}
}
public static List <Sprite> GetSprites(string tileSet, string tileName)
{
List <Sprite> sprites = new List <Sprite>();
if (Sprites.ContainsKey(tileSet))
{
List <Tuple <string, Sprite> > find = Sprites[tileSet].FindAll(x => x.First.Contains(tileName));
foreach (Tuple <string, Sprite> found in find)
{
sprites.Add(found.Second);
}
}
if (sprites.Count == 0)
{
List <Sprite> defaultSprite = new List <Sprite>();
defaultSprite.Add(Sprites["DEFAULT"][0].Second);
return(defaultSprite);
}
return(sprites);
}
private void InitializeSprites(int tileWidth, int tileHeight)
{
Sprites.Clear();
for (int x = 0; x < numColumns; x++)
{
for (int y = 0; y < numRows; y++)
{
Sprite sprite = Sprites.CreateSprite(matrixes[0], new Frame(tilesheet, x, y),
x.ToString() + "-" + y.ToString());
sprite.MoveSprite((float)x, (float)y);
sprite.Visible = true;
}
}
// remove the bottom-right tile; this will be the space for sliding
int maxX = numColumns - 1;
int maxY = numRows - 1;
Sprites.GetSpriteByID(maxX.ToString() + "-" + maxY.ToString()).Dispose();
openSpace = new Point(maxX, maxY);
}
public void Spawn(string name, Sprites sprite, string color, string token)
{
// sanitize the name
if (name != null &&
name.Length > World.Hook.MaxNameLength)
{
name = name.Substring(0, World.Hook.MaxNameLength);
}
CummulativeBoostRequested = false;
CummulativeShootRequested = false;
Name = name;
ShipSprite = sprite;
Color = color;
Token = token;
AliveSince = World.Time;
IsSpawning = true;
}
protected override void OnUpdateLogic(float lastFrameTimeInSecond)
{
base.OnUpdateLogic(lastFrameTimeInSecond);
if (Focused)
{
Keyboard.GetCurrentState(ref KeyboardState);
}
else
{
KeyboardState.PressedKeys.Clear();
}
Mouse.GetCurrentState(ref MouseState);
MouseClientPosition = PointToClient(System.Windows.Forms.Cursor.Position).ToVector2();
if (!new Rectangle(0, 0, ClientSize.Width, ClientSize.Height).Contains(
(int)MouseClientPosition.X, (int)MouseClientPosition.Y))
{
MouseState.Z = 0;
}
foreach (var sprite in Sprites.Values)
{
sprite.OnUpdate(lastFrameTimeInSecond);
}
var toDestroyIds = Sprites.Values.Where(x => x.ReadyToRemove).Select(x => x.Id).ToList();
if (toDestroyIds.Count > 0)
{
foreach (var id in toDestroyIds)
{
Sprites[id].Dispose();
Sprites.Remove(id);
}
World.ProcessChanges();
}
}
private Grid GetGrid(int x, int y)
{
Sprites ss = GetSprites();
if (ss == null)
{
return(null);
}
ISprite[] s = ss.GetSprites();
for (int i = 0; i < s.Length; i++)
{
if (s[i] is Grid)
{
Grid g = (Grid)s[i];
if (g.GetCollisionBox().Contains(x, y))
{
return(g);
}
}
}
return(null);
}
public void StartSpriteSheetGeneration()
{
MilkshakePreferences prefs = MilkshakeForm.Instance.Preferences;
CheckForNewEntry(comboBoxInputDir.Text, this.LastInputDir);
CheckForNewEntry(comboBoxOutputDir.Text, this.LastOutputDir);
CheckForNewEntry(comboBoxName.Text, this.LastNames);
prefs.ToolSpritesheetLastInputFolder = ConvertListToString(this.LastInputDir);
prefs.ToolSpritesheetLastOutputFolder = ConvertListToString(this.LastOutputDir);
prefs.ToolSpritesheetLastOutputName = ConvertListToString(this.LastNames);
prefs.ToolSpritesheetLastSafeBorderSize = (int)numericUpDownSafeBorderSize.Value;
prefs.ToolSpritesheetLastCorrectTransparencyColor = checkBoxAlphaCorrection.Checked;
prefs.ToolSpritesheetLastReplaceBaseColor = checkBoxOverrideBaseColor.Checked;
prefs.ToolSpritesheetLastPadTexturePowerOfTwo = checkBoxPowerOf2.Checked;
prefs.ToolSpritesheetLastBaseColor = new XnaColor(this.BaseTextureColor.R,
this.BaseTextureColor.G, this.BaseTextureColor.B);
this.Sprites.Clear();
String path = comboBoxInputDir.Text;
DirectoryInfo di = new DirectoryInfo(path);
FileInfo[] rgFiles = di.GetFiles("*.*");
foreach (FileInfo fi in rgFiles)
{
String fileExt = fi.Extension.ToLower();
if (fileExt == ".png" || fileExt == ".jpg" ||
fileExt == ".dds" || fileExt == ".bmp" || fileExt == ".tga")
{
Console.WriteLine(Sprites.Count + "] Packing sprite " + fi.Name);
SpriteInfo newInfo = new SpriteInfo(Path.GetFileNameWithoutExtension(fi.Name));
newInfo.Texture2D = Texture2D.FromFile(IceCream.Drawing.DrawingManager.GraphicsDevice, fi.FullName);
newInfo.PixelData = new uint[newInfo.Texture2D.Width * newInfo.Texture2D.Height];
newInfo.Texture2D.GetData <uint>(newInfo.PixelData);
Sprites.Add(newInfo);
}
}
PackSprites((int)numericUpDownSafeBorderSize.Value, comboBoxOutputDir.Text, comboBoxName.Text);
}
public void Spawn(string name, Sprites sprite, string color, string token, string userColor = null)
{
if (IsAlive || IsSpawning)
{
return;
}
if (!World.CanSpawn)
{
if (World.CanSpawnReason != null)
{
SendMessage(World.CanSpawnReason);
}
return;
}
UserColor = userColor;
// sanitize the name
if (name != null &&
name.Length > World.Hook.MaxNameLength)
{
name = name.Substring(0, World.Hook.MaxNameLength);
}
CummulativeBoostRequested = false;
CummulativeShootRequested = false;
Name = name;
ShipSprite = sprite;
Color = color;
Token = token;
AliveSince = World.Time;
IsSpawning = true;
}
protected override void LoadContent()
{
Content.RootDirectory = "";
IsMouseVisible = true;
PandaMonogameConfig.Logging = true;
ModManager.Instance.Init(Content);
ModManager.Instance.LoadList("Mods", "mods.xml", "assets.xml");
ModManager.Instance.ImportAssets();
ModManager.Instance.AssetManager.Import("Assets\\assets.xml");
SettingsManager.Instance.Load("Assets\\settings.xml");
#if DEBUG
IsFixedTimeStep = false;
_graphics.SynchronizeWithVerticalRetrace = false;
#endif
_graphics.PreferredBackBufferWidth = SettingsManager.Instance.GetSetting <int>("window", "width");
_graphics.PreferredBackBufferHeight = SettingsManager.Instance.GetSetting <int>("window", "height");
_graphics.ApplyChanges();
ModManager.Instance.SoundManager.SetVolume((int)SoundType.Music, SettingsManager.Instance.GetSetting <float>("sound", "musicvolume"));
ModManager.Instance.SoundManager.SetVolume((int)SoundType.SoundEffect, SettingsManager.Instance.GetSetting <float>("sound", "sfxvolume"));
ModManager.Instance.SoundManager.SetVolume((int)SoundType.UI, SettingsManager.Instance.GetSetting <float>("sound", "uivolume"));
_spriteBatch = new SpriteBatch(GraphicsDevice);
Sprites.Load(GraphicsDevice);
WorldData.Load();
EntityData.Load();
//ChangeGameState((int)GameStateType.Startup);
ChangeGameState((int)GameStateType.Menu);
Window.TextInput += Window_TextInput;
}
//A classe fábrica também oferece um método para obter o objeto.
//Assim, o acesso a estes objetos fica centralizado e unificado a partir desta classe.
public ISpriteFlyweight getFlyweight(Sprites jogador)
{
switch (jogador)
{
case Sprites.JOGADOR:
return(flyweights.ElementAt(0));
case Sprites.INIMIGO_1:
return(flyweights.ElementAt(1));
case Sprites.INIMIGO_2:
return(flyweights.ElementAt(2));
case Sprites.INIMIGO_3:
return(flyweights.ElementAt(3));
case Sprites.CENARIO_1:
return(flyweights.ElementAt(4));
default:
return(flyweights.ElementAt(5));
}
}
/// <summary>
/// Checks if any visible portion of a sprite intersects current node
/// </summary>
/// <param name="_sprite">Sprite to check</param>
/// <returns>True if sprite is intersects current node</returns>
private bool IntersectsNode(Sprites.CollidableSprite _sprite)
{
return ((_sprite.NegX > NegX && _sprite.NegX < PosX) || (_sprite.PosX > NegX && _sprite.PosX < PosX)) &&
((_sprite.NegY > NegY && _sprite.NegY < PosY) || (_sprite.PosY > NegX && _sprite.PosY < PosY));
}
/// <summary>
/// Checks if the collidable portion of a sprite is contained inside current node
/// </summary>
/// <param name="_sprite">Sprite to check</param>
/// <returns>True if sprite is contained inside current node</returns>
private bool InNode(Sprites.CollidableSprite _sprite)
{
return _sprite.CollidableNegX > NegX &&
_sprite.CollidablePosX < PosX &&
_sprite.CollidableNegY > NegY &&
_sprite.CollidablePosY < PosY;
}
public void Destroy()
{
lock (this)
{
useKeyListener = false;
useTouchListener = false;
replaceLoading = false;
replaceDelay.SetDelay(10);
tx = ty = 0;
isClose = true;
CallEvents(false);
isTranslate = false;
isNext = false;
isGravity = false;
isCamera = false;
isLock = true;
if (touchs != null)
{
touchs.Clear();
touchs = null;
}
if (keys != null)
{
keys.Clear();
touchs = null;
}
if (sprites != null)
{
sprites.Dispose();
sprites = null;
}
if (desktop != null)
{
desktop.Dispose();
desktop = null;
}
if (currentScreen != null)
{
LTexture parent = currentScreen.GetParent();
if (parent != null)
{
parent.CloseChildAll();
parent.Destroy();
}
else
{
currentScreen.Destroy();
}
currentScreen = null;
}
if (gravityHandler != null)
{
gravityHandler.Dispose();
gravityHandler = null;
}
camera = null;
if (releases != null)
{
foreach (LRelease r in releases)
{
if (r != null)
{
r.Dispose();
}
}
releases.Clear();
}
Dispose();
}
}
public virtual void Destroy()
{
lock (this)
{
if (useScreenListener)
{
foreach (ScreenListener t in screens)
{
t.Dispose();
}
}
useScreenListener = false;
replaceLoading = false;
replaceDelay.SetDelay(10);
tx = ty = 0;
isClose = true;
CallEvents(false);
isTranslate = false;
isNext = false;
isGravity = false;
isNext = false;
isLock = true;
if (sprites != null)
{
sprites.Dispose();
sprites = null;
}
if (desktop != null)
{
desktop.Dispose();
desktop = null;
}
if (currentScreen != null)
{
LTexture parent = currentScreen.GetParent();
if (parent != null)
{
parent.CloseChildAll();
parent.Destroy();
}
else
{
currentScreen.Destroy();
}
currentScreen = null;
}
if (gravityHandler != null)
{
gravityHandler.Dispose();
gravityHandler = null;
}
if (releases != null)
{
foreach (LRelease r in releases)
{
if (r != null)
{
r.Dispose();
}
}
CollectionUtils.Clear(releases);
}
Dispose();
}
}
/// <summary>
/// Adds a sprite to the QuadTree
/// </summary>
/// <param name="_sprite">Sprite to add</param>
public void Add(Sprites.CollidableSprite _sprite)
{
root.Add(_sprite);
}
// Use this for initialization
void Start()
{
genderChar = ChooseGender();
GameObject nameBox = (GameObject)Instantiate(nameBoxType, new Vector3(this.transform.position.x, this.transform.position.y - 1, this.transform.position.z), Quaternion.identity);
nameBox.GetComponent<TextMesh>().text = NameScript.GetName(this.tag, genderChar);
nameBox.transform.parent = this.transform;
spriteHolder = GameObject.Find("SpritesHolder").GetComponent<Sprites>();
SpriteRenderer thisSprite = this.transform.GetChild(0).GetComponent<SpriteRenderer>();
thisSprite.sprite = spriteHolder.GetZombieSprite(genderChar);
// Determine type of zombie, and set stats accordingly
// Female Zombie Brute
if (thisSprite.sprite == spriteHolder.spriteZombiesF[0]){
this.transform.GetComponent<AIMovement>().moveSpeed = Random.Range(2.0f, 2.6f);
health = 4;
damage = 2;
score = 10;
dropChance = 35.0f;
}
// Crawling Zombie
else if (thisSprite.sprite == spriteHolder.spriteZombiesF[0] || thisSprite.sprite == spriteHolder.spriteZombiesM[2] )
{
this.transform.GetComponent<AIMovement>().moveSpeed = Random.Range(0.5f, 1.6f);
health = 2;
damage = 1;
score = 5;
dropChance = 15.0f;
}
// Male Zombie Brute
else if (thisSprite.sprite == spriteHolder.spriteZombiesM[0]){
this.transform.GetComponent<AIMovement>().moveSpeed = Random.Range(2.5f, 2.9f);
health = 2;
damage = 2;
score = 10;
dropChance = 35.0f;
}
// Fast Zombie
else if (thisSprite.sprite == spriteHolder.spriteZombiesM[1]){
this.transform.GetComponent<AIMovement>().moveSpeed = Random.Range(2.8f, 3.5f);
health = 3;
damage = 1;
score = 8;
dropChance = 15.0f;
}
thisSprite.color = new Color(Random.Range(0.8f, 1f), Random.Range(0.8f, 1f), Random.Range(0.8f, 1f));
}
public static void RenderMoveTargettingDisplay(RendererDestinationData destData, Sprites.ISprite attacker, Logic.Moves.Move move)
{
switch (move.RangeType) {
case Enums.MoveRange.FrontOfUserUntil:
case Enums.MoveRange.LineUntilHit:
{
#region Front of user Until
switch (attacker.Direction)
{
case Enums.Direction.Up:
{
int y = attacker.Y;
for (int i = 1; i <= move.Range; i++)
{
y = attacker.Y - i;
//if (!ShouldContinueRenderingTargettingDisplay(Logic.Maps.MapHelper.ActiveMap,
// attacker.X, y)) {
// break;
//}
if (!Screen.ScreenRenderer.CanBeSeen(new Point(attacker.X, y), Enums.MapID.Active))
{
destData.Blit(srfcMoveTargetTileDark, new Point(Screen.ScreenRenderer.ToTileX(attacker.X), Screen.ScreenRenderer.ToTileY(y) + Logic.Players.PlayerManager.MyPlayer.Offset.Y));
} else if (!IsRenderingTargetOnSprite(Logic.Maps.MapHelper.ActiveMap,
attacker.X, y))
{
destData.Blit(srfcMoveTargetTile, new Point(Screen.ScreenRenderer.ToTileX(attacker.X), Screen.ScreenRenderer.ToTileY(y) + Logic.Players.PlayerManager.MyPlayer.Offset.Y));
}
else
{
destData.Blit(srfcMoveTargetTileHit, new Point(Screen.ScreenRenderer.ToTileX(attacker.X), Screen.ScreenRenderer.ToTileY(y) + Logic.Players.PlayerManager.MyPlayer.Offset.Y));
break;
}
}
}
break;
case Enums.Direction.Down:
{
int y = attacker.Y;
for (int i = 1; i <= move.Range; i++)
{
y = attacker.Y + i;
//if (!ShouldContinueRenderingTargettingDisplay(Logic.Maps.MapHelper.ActiveMap,
// attacker.X, y)) {
// break;
//}
if (!Screen.ScreenRenderer.CanBeSeen(new Point(attacker.X, y), Enums.MapID.Active)) {
destData.Blit(srfcMoveTargetTileDark, new Point(Screen.ScreenRenderer.ToTileX(attacker.X), Screen.ScreenRenderer.ToTileY(y) + Logic.Players.PlayerManager.MyPlayer.Offset.Y));
} else if (!IsRenderingTargetOnSprite(Logic.Maps.MapHelper.ActiveMap,
attacker.X, y))
{
destData.Blit(srfcMoveTargetTile, new Point(Screen.ScreenRenderer.ToTileX(attacker.X), Screen.ScreenRenderer.ToTileY(y) + Logic.Players.PlayerManager.MyPlayer.Offset.Y));
}
else
{
destData.Blit(srfcMoveTargetTileHit, new Point(Screen.ScreenRenderer.ToTileX(attacker.X), Screen.ScreenRenderer.ToTileY(y) + Logic.Players.PlayerManager.MyPlayer.Offset.Y));
break;
}
}
}
break;
case Enums.Direction.Left:
{
int x = attacker.X;
for (int i = 1; i <= move.Range; i++)
{
x = attacker.X - i;
//if (!ShouldContinueRenderingTargettingDisplay(Logic.Maps.MapHelper.ActiveMap,
// x, attacker.Y)) {
// break;
//}
if (!Screen.ScreenRenderer.CanBeSeen(new Point(x, attacker.Y), Enums.MapID.Active)) {
destData.Blit(srfcMoveTargetTileDark, new Point(Screen.ScreenRenderer.ToTileX(x) + Logic.Players.PlayerManager.MyPlayer.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y)));
} else if (!IsRenderingTargetOnSprite(Logic.Maps.MapHelper.ActiveMap,
x, attacker.Y))
{
destData.Blit(srfcMoveTargetTile, new Point(Screen.ScreenRenderer.ToTileX(x) + Logic.Players.PlayerManager.MyPlayer.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y)));
}
else
{
destData.Blit(srfcMoveTargetTileHit, new Point(Screen.ScreenRenderer.ToTileX(x) + Logic.Players.PlayerManager.MyPlayer.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y)));
break;
}
}
}
break;
case Enums.Direction.Right:
{
int x = attacker.X;
for (int i = 1; i <= move.Range; i++)
{
x = attacker.X + i;
//if (!ShouldContinueRenderingTargettingDisplay(Logic.Maps.MapHelper.ActiveMap,
// x, attacker.Y)) {
// break;
//}
if (!Screen.ScreenRenderer.CanBeSeen(new Point(x, attacker.Y), Enums.MapID.Active)) {
destData.Blit(srfcMoveTargetTileDark, new Point(Screen.ScreenRenderer.ToTileX(x) + Logic.Players.PlayerManager.MyPlayer.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y)));
} else if (!IsRenderingTargetOnSprite(Logic.Maps.MapHelper.ActiveMap,
x, attacker.Y))
{
destData.Blit(srfcMoveTargetTile, new Point(Screen.ScreenRenderer.ToTileX(x) + Logic.Players.PlayerManager.MyPlayer.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y)));
}
else
{
destData.Blit(srfcMoveTargetTileHit, new Point(Screen.ScreenRenderer.ToTileX(x) + Logic.Players.PlayerManager.MyPlayer.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y)));
break;
}
}
}
break;
}
#endregion
}
break;
case Enums.MoveRange.StraightLine:
case Enums.MoveRange.FrontOfUser: {
#region Front of user
switch (attacker.Direction) {
case Enums.Direction.Up: {
int y = attacker.Y;
for (int i = 1; i <= move.Range; i++) {
y = attacker.Y - i;
//if (!ShouldContinueRenderingTargettingDisplay(Logic.Maps.MapHelper.ActiveMap,
// attacker.X, y)) {
// break;
//}
if (!Screen.ScreenRenderer.CanBeSeen(new Point(attacker.X, y), Enums.MapID.Active)) {
destData.Blit(srfcMoveTargetTileDark, new Point(Screen.ScreenRenderer.ToTileX(attacker.X), Screen.ScreenRenderer.ToTileY(y) + Logic.Players.PlayerManager.MyPlayer.Offset.Y));
} else if (!IsRenderingTargetOnSprite(Logic.Maps.MapHelper.ActiveMap,
attacker.X, y)) {
destData.Blit(srfcMoveTargetTile, new Point(Screen.ScreenRenderer.ToTileX(attacker.X), Screen.ScreenRenderer.ToTileY(y) + Logic.Players.PlayerManager.MyPlayer.Offset.Y));
} else {
destData.Blit(srfcMoveTargetTileHit, new Point(Screen.ScreenRenderer.ToTileX(attacker.X), Screen.ScreenRenderer.ToTileY(y) + Logic.Players.PlayerManager.MyPlayer.Offset.Y));
}
}
}
break;
case Enums.Direction.Down: {
int y = attacker.Y;
for (int i = 1; i <= move.Range; i++) {
y = attacker.Y + i;
//if (!ShouldContinueRenderingTargettingDisplay(Logic.Maps.MapHelper.ActiveMap,
// attacker.X, y)) {
// break;
//}
if (!Screen.ScreenRenderer.CanBeSeen(new Point(attacker.X, y), Enums.MapID.Active)) {
destData.Blit(srfcMoveTargetTileDark, new Point(Screen.ScreenRenderer.ToTileX(attacker.X), Screen.ScreenRenderer.ToTileY(y) + Logic.Players.PlayerManager.MyPlayer.Offset.Y));
} else if (!IsRenderingTargetOnSprite(Logic.Maps.MapHelper.ActiveMap,
attacker.X, y)) {
destData.Blit(srfcMoveTargetTile, new Point(Screen.ScreenRenderer.ToTileX(attacker.X), Screen.ScreenRenderer.ToTileY(y) + Logic.Players.PlayerManager.MyPlayer.Offset.Y));
} else {
destData.Blit(srfcMoveTargetTileHit, new Point(Screen.ScreenRenderer.ToTileX(attacker.X), Screen.ScreenRenderer.ToTileY(y) + Logic.Players.PlayerManager.MyPlayer.Offset.Y));
}
}
}
break;
case Enums.Direction.Left: {
int x = attacker.X;
for (int i = 1; i <= move.Range; i++) {
x = attacker.X - i;
//if (!ShouldContinueRenderingTargettingDisplay(Logic.Maps.MapHelper.ActiveMap,
// x, attacker.Y)) {
// break;
//}
if (!Screen.ScreenRenderer.CanBeSeen(new Point(x, attacker.Y), Enums.MapID.Active)) {
destData.Blit(srfcMoveTargetTileDark, new Point(Screen.ScreenRenderer.ToTileX(x) + Logic.Players.PlayerManager.MyPlayer.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y)));
} else if (!IsRenderingTargetOnSprite(Logic.Maps.MapHelper.ActiveMap,
x, attacker.Y)) {
destData.Blit(srfcMoveTargetTile, new Point(Screen.ScreenRenderer.ToTileX(x) + Logic.Players.PlayerManager.MyPlayer.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y)));
} else {
destData.Blit(srfcMoveTargetTileHit, new Point(Screen.ScreenRenderer.ToTileX(x) + Logic.Players.PlayerManager.MyPlayer.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y)));
}
}
}
break;
case Enums.Direction.Right: {
int x = attacker.X;
for (int i = 1; i <= move.Range; i++) {
x = attacker.X + i;
//if (!ShouldContinueRenderingTargettingDisplay(Logic.Maps.MapHelper.ActiveMap,
// x, attacker.Y)) {
// break;
//}
if (!Screen.ScreenRenderer.CanBeSeen(new Point(x, attacker.Y), Enums.MapID.Active)) {
destData.Blit(srfcMoveTargetTileDark, new Point(Screen.ScreenRenderer.ToTileX(x) + Logic.Players.PlayerManager.MyPlayer.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y)));
} else if (!IsRenderingTargetOnSprite(Logic.Maps.MapHelper.ActiveMap,
x, attacker.Y)) {
destData.Blit(srfcMoveTargetTile, new Point(Screen.ScreenRenderer.ToTileX(x) + Logic.Players.PlayerManager.MyPlayer.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y)));
} else {
destData.Blit(srfcMoveTargetTileHit, new Point(Screen.ScreenRenderer.ToTileX(x) + Logic.Players.PlayerManager.MyPlayer.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y)));
}
}
}
break;
}
#endregion
}
break;
case Enums.MoveRange.User: {
#region user
destData.Blit(srfcMoveTargetTileHit, new Point(Screen.ScreenRenderer.ToTileX(attacker.X) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y) + attacker.Offset.Y));
#endregion
}
break;
case Enums.MoveRange.Special:
{
#region Special
destData.Blit(srfcMoveTargetUnknown, new Point(Screen.ScreenRenderer.ToTileX(attacker.X - 1) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y - 1) + attacker.Offset.Y));
#endregion
}
break;
case Enums.MoveRange.Floor:
{
#region Floor
int startX = Screen.ScreenRenderer.GetScreenLeft() - 1;
int startY = Screen.ScreenRenderer.GetScreenTop();
if (startX < 0)
{
startX = 0;
}
else if (startX + 19 > Screen.ScreenRenderer.RenderOptions.Map.MaxX)
{
startX = Screen.ScreenRenderer.RenderOptions.Map.MaxX - 19;
}
if (startY < 0)
{
startY = 0;
}
else if (startY + 14 > Screen.ScreenRenderer.RenderOptions.Map.MaxY)
{
startY = Screen.ScreenRenderer.RenderOptions.Map.MaxY - 14;
}
for (int x = startX; x < startX + 20; x++)
{
for (int y = startY; y < startY + 15; y++)
{
if (!Screen.ScreenRenderer.CanBeSeen(new Point(x, y), Enums.MapID.Active)) {
destData.Blit(srfcMoveTargetTileDark, new Point(Screen.ScreenRenderer.ToTileX(x), Screen.ScreenRenderer.ToTileY(y)));
} else if (!IsRenderingTargetOnSprite(Logic.Maps.MapHelper.ActiveMap,
x, y))
{
destData.Blit(srfcMoveTargetTile, new Point(Screen.ScreenRenderer.ToTileX(x), Screen.ScreenRenderer.ToTileY(y)));
}
else
{
destData.Blit(srfcMoveTargetTileHit, new Point(Screen.ScreenRenderer.ToTileX(x), Screen.ScreenRenderer.ToTileY(y)));
}
}
}
#endregion
}
break;
case Enums.MoveRange.Room:
{
#region Room
for (int x = attacker.X - move.Range; x <= attacker.X + move.Range; x++)
{
for (int y = attacker.Y - move.Range; y <= attacker.Y + move.Range; y++)
{
if (!Screen.ScreenRenderer.CanBeSeen(new Point(x, y), Enums.MapID.Active)) {
destData.Blit(srfcMoveTargetTileDark, new Point(Screen.ScreenRenderer.ToTileX(x), Screen.ScreenRenderer.ToTileY(y)));
} else if (!IsRenderingTargetOnSprite(Logic.Maps.MapHelper.ActiveMap,
x, y))
{
destData.Blit(srfcMoveTargetTile, new Point(Screen.ScreenRenderer.ToTileX(x) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(y) + attacker.Offset.Y));
}
else
{
destData.Blit(srfcMoveTargetTileHit, new Point(Screen.ScreenRenderer.ToTileX(x) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(y) + attacker.Offset.Y));
}
}
}
#endregion
}
break;
case Enums.MoveRange.FrontAndSides:
{
#region Front and Sides
for (int r = 0; r <= move.Range; r++)
{
//check adjacent tiles
switch (attacker.Direction)
{
case Enums.Direction.Down:
{
if (!Screen.ScreenRenderer.CanBeSeen(new Point(attacker.X, attacker.Y + r), Enums.MapID.Active)) {
destData.Blit(srfcMoveTargetTileDark, new Point(Screen.ScreenRenderer.ToTileX(attacker.X) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y + r) + attacker.Offset.Y));
} else if (!IsRenderingTargetOnSprite(Logic.Maps.MapHelper.ActiveMap,
attacker.X, attacker.Y + r))
{
destData.Blit(srfcMoveTargetTile, new Point(Screen.ScreenRenderer.ToTileX(attacker.X) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y + r) + attacker.Offset.Y));
}
else
{
destData.Blit(srfcMoveTargetTileHit, new Point(Screen.ScreenRenderer.ToTileX(attacker.X) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y + r) + attacker.Offset.Y));
}
for (int s = 1; s <= r; s++)
{
if (!Screen.ScreenRenderer.CanBeSeen(new Point(attacker.X - s, attacker.Y + r), Enums.MapID.Active)) {
destData.Blit(srfcMoveTargetTileDark, new Point(Screen.ScreenRenderer.ToTileX(attacker.X - s) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y + r) + attacker.Offset.Y));
} else if (!IsRenderingTargetOnSprite(Logic.Maps.MapHelper.ActiveMap,
attacker.X - s, attacker.Y + r))
{
destData.Blit(srfcMoveTargetTile, new Point(Screen.ScreenRenderer.ToTileX(attacker.X - s) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y + r) + attacker.Offset.Y));
}
else
{
destData.Blit(srfcMoveTargetTileHit, new Point(Screen.ScreenRenderer.ToTileX(attacker.X - s) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y + r) + attacker.Offset.Y));
}
if (!Screen.ScreenRenderer.CanBeSeen(new Point(attacker.X + s, attacker.Y + r), Enums.MapID.Active)) {
destData.Blit(srfcMoveTargetTileDark, new Point(Screen.ScreenRenderer.ToTileX(attacker.X + s) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y + r) + attacker.Offset.Y));
} else if (!IsRenderingTargetOnSprite(Logic.Maps.MapHelper.ActiveMap,
attacker.X + s, attacker.Y + r))
{
destData.Blit(srfcMoveTargetTile, new Point(Screen.ScreenRenderer.ToTileX(attacker.X + s) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y + r) + attacker.Offset.Y));
}
else
{
destData.Blit(srfcMoveTargetTileHit, new Point(Screen.ScreenRenderer.ToTileX(attacker.X + s) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y + r) + attacker.Offset.Y));
}
}
}
break;
case Enums.Direction.Up:
{
if (!Screen.ScreenRenderer.CanBeSeen(new Point(attacker.X, attacker.Y - r), Enums.MapID.Active)) {
destData.Blit(srfcMoveTargetTileDark, new Point(Screen.ScreenRenderer.ToTileX(attacker.X) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y - r) + attacker.Offset.Y));
} else if (!IsRenderingTargetOnSprite(Logic.Maps.MapHelper.ActiveMap,
attacker.X, attacker.Y - r))
{
destData.Blit(srfcMoveTargetTile, new Point(Screen.ScreenRenderer.ToTileX(attacker.X) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y - r) + attacker.Offset.Y));
}
else
{
destData.Blit(srfcMoveTargetTileHit, new Point(Screen.ScreenRenderer.ToTileX(attacker.X) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y - r) + attacker.Offset.Y));
}
for (int s = 1; s <= r; s++)
{
if (!Screen.ScreenRenderer.CanBeSeen(new Point(attacker.X - s, attacker.Y - r), Enums.MapID.Active)) {
destData.Blit(srfcMoveTargetTileDark, new Point(Screen.ScreenRenderer.ToTileX(attacker.X - s) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y - r) + attacker.Offset.Y));
} else if (!IsRenderingTargetOnSprite(Logic.Maps.MapHelper.ActiveMap,
attacker.X - s, attacker.Y - r))
{
destData.Blit(srfcMoveTargetTile, new Point(Screen.ScreenRenderer.ToTileX(attacker.X - s) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y - r) + attacker.Offset.Y));
}
else
{
destData.Blit(srfcMoveTargetTileHit, new Point(Screen.ScreenRenderer.ToTileX(attacker.X - s) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y - r) + attacker.Offset.Y));
}
if (!Screen.ScreenRenderer.CanBeSeen(new Point(attacker.X + s, attacker.Y - r), Enums.MapID.Active)) {
destData.Blit(srfcMoveTargetTileDark, new Point(Screen.ScreenRenderer.ToTileX(attacker.X + s) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y - r) + attacker.Offset.Y));
} else if (!IsRenderingTargetOnSprite(Logic.Maps.MapHelper.ActiveMap,
attacker.X + s, attacker.Y - r))
{
destData.Blit(srfcMoveTargetTile, new Point(Screen.ScreenRenderer.ToTileX(attacker.X + s) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y - r) + attacker.Offset.Y));
}
else
{
destData.Blit(srfcMoveTargetTileHit, new Point(Screen.ScreenRenderer.ToTileX(attacker.X + s) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y - r) + attacker.Offset.Y));
}
}
}
break;
case Enums.Direction.Left:
{
if (!Screen.ScreenRenderer.CanBeSeen(new Point(attacker.X - r, attacker.Y), Enums.MapID.Active)) {
destData.Blit(srfcMoveTargetTileDark, new Point(Screen.ScreenRenderer.ToTileX(attacker.X - r) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y) + attacker.Offset.Y));
} else if (!IsRenderingTargetOnSprite(Logic.Maps.MapHelper.ActiveMap,
attacker.X - r, attacker.Y))
{
destData.Blit(srfcMoveTargetTile, new Point(Screen.ScreenRenderer.ToTileX(attacker.X - r) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y) + attacker.Offset.Y));
}
else
{
destData.Blit(srfcMoveTargetTileHit, new Point(Screen.ScreenRenderer.ToTileX(attacker.X - r) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y) + attacker.Offset.Y));
}
for (int s = 1; s <= r; s++)
{
if (!Screen.ScreenRenderer.CanBeSeen(new Point(attacker.X - r, attacker.Y - s), Enums.MapID.Active)) {
destData.Blit(srfcMoveTargetTileDark, new Point(Screen.ScreenRenderer.ToTileX(attacker.X - r) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y - s) + attacker.Offset.Y));
} else if (!IsRenderingTargetOnSprite(Logic.Maps.MapHelper.ActiveMap,
attacker.X - r, attacker.Y - s))
{
destData.Blit(srfcMoveTargetTile, new Point(Screen.ScreenRenderer.ToTileX(attacker.X - r) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y - s) + attacker.Offset.Y));
}
else
{
destData.Blit(srfcMoveTargetTileHit, new Point(Screen.ScreenRenderer.ToTileX(attacker.X - r) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y - s) + attacker.Offset.Y));
}
if (!Screen.ScreenRenderer.CanBeSeen(new Point(attacker.X - r, attacker.Y + s), Enums.MapID.Active)) {
destData.Blit(srfcMoveTargetTileDark, new Point(Screen.ScreenRenderer.ToTileX(attacker.X - r) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y + s) + attacker.Offset.Y));
} else if (!IsRenderingTargetOnSprite(Logic.Maps.MapHelper.ActiveMap,
attacker.X - r, attacker.Y + s))
{
destData.Blit(srfcMoveTargetTile, new Point(Screen.ScreenRenderer.ToTileX(attacker.X - r) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y + s) + attacker.Offset.Y));
}
else
{
destData.Blit(srfcMoveTargetTileHit, new Point(Screen.ScreenRenderer.ToTileX(attacker.X - r) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y + s) + attacker.Offset.Y));
}
}
}
break;
case Enums.Direction.Right:
{
if (!Screen.ScreenRenderer.CanBeSeen(new Point(attacker.X + r, attacker.Y), Enums.MapID.Active)) {
destData.Blit(srfcMoveTargetTileDark, new Point(Screen.ScreenRenderer.ToTileX(attacker.X + r) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y) + attacker.Offset.Y));
} else if (!IsRenderingTargetOnSprite(Logic.Maps.MapHelper.ActiveMap,
attacker.X + r, attacker.Y))
{
destData.Blit(srfcMoveTargetTile, new Point(Screen.ScreenRenderer.ToTileX(attacker.X + r) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y) + attacker.Offset.Y));
}
else
{
destData.Blit(srfcMoveTargetTileHit, new Point(Screen.ScreenRenderer.ToTileX(attacker.X + r) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y) + attacker.Offset.Y));
}
for (int s = 1; s <= r; s++)
{
if (!Screen.ScreenRenderer.CanBeSeen(new Point(attacker.X + r, attacker.Y - s), Enums.MapID.Active)) {
destData.Blit(srfcMoveTargetTileDark, new Point(Screen.ScreenRenderer.ToTileX(attacker.X + r) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y - s) + attacker.Offset.Y));
} else if (!IsRenderingTargetOnSprite(Logic.Maps.MapHelper.ActiveMap,
attacker.X + r, attacker.Y - s))
{
destData.Blit(srfcMoveTargetTile, new Point(Screen.ScreenRenderer.ToTileX(attacker.X + r) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y - s) + attacker.Offset.Y));
}
else
{
destData.Blit(srfcMoveTargetTileHit, new Point(Screen.ScreenRenderer.ToTileX(attacker.X + r) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y - s) + attacker.Offset.Y));
}
if (!Screen.ScreenRenderer.CanBeSeen(new Point(attacker.X + r, attacker.Y + s), Enums.MapID.Active)) {
destData.Blit(srfcMoveTargetTileDark, new Point(Screen.ScreenRenderer.ToTileX(attacker.X + r) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y + s) + attacker.Offset.Y));
} else if (!IsRenderingTargetOnSprite(Logic.Maps.MapHelper.ActiveMap,
attacker.X + r, attacker.Y + s))
{
destData.Blit(srfcMoveTargetTile, new Point(Screen.ScreenRenderer.ToTileX(attacker.X + r) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y + s) + attacker.Offset.Y));
}
else
{
destData.Blit(srfcMoveTargetTileHit, new Point(Screen.ScreenRenderer.ToTileX(attacker.X + r) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y + s) + attacker.Offset.Y));
}
}
}
break;
}
}
#endregion
}
break;
case Enums.MoveRange.ArcThrow:
{
#region Arc Throw
bool stopattile = false;
for (int r = 0; r <= move.Range; r++)
{
//check adjacent tiles
switch (attacker.Direction)
{
case Enums.Direction.Down:
{
if (!Screen.ScreenRenderer.CanBeSeen(new Point(attacker.X, attacker.Y + r), Enums.MapID.Active)) {
destData.Blit(srfcMoveTargetTileDark, new Point(Screen.ScreenRenderer.ToTileX(attacker.X) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y + r) + attacker.Offset.Y));
} else if (!IsRenderingTargetOnSprite(Logic.Maps.MapHelper.ActiveMap,
attacker.X, attacker.Y + r))
{
destData.Blit(srfcMoveTargetTile, new Point(Screen.ScreenRenderer.ToTileX(attacker.X) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y + r) + attacker.Offset.Y));
}
else
{
destData.Blit(srfcMoveTargetTileHit, new Point(Screen.ScreenRenderer.ToTileX(attacker.X) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y + r) + attacker.Offset.Y));
stopattile = true;
}
if (stopattile)
{
break;
}
for (int s = 1; s <= r; s++)
{
if (!Screen.ScreenRenderer.CanBeSeen(new Point(attacker.X - s, attacker.Y + r), Enums.MapID.Active)) {
destData.Blit(srfcMoveTargetTileDark, new Point(Screen.ScreenRenderer.ToTileX(attacker.X - s) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y + r) + attacker.Offset.Y));
} else if (!IsRenderingTargetOnSprite(Logic.Maps.MapHelper.ActiveMap,
attacker.X - s, attacker.Y + r))
{
destData.Blit(srfcMoveTargetTile, new Point(Screen.ScreenRenderer.ToTileX(attacker.X - s) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y + r) + attacker.Offset.Y));
}
else
{
destData.Blit(srfcMoveTargetTileHit, new Point(Screen.ScreenRenderer.ToTileX(attacker.X - s) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y + r) + attacker.Offset.Y));
stopattile = true;
}
if (stopattile)
{
break;
}
if (!Screen.ScreenRenderer.CanBeSeen(new Point(attacker.X + s, attacker.Y + r), Enums.MapID.Active)) {
destData.Blit(srfcMoveTargetTileDark, new Point(Screen.ScreenRenderer.ToTileX(attacker.X + s) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y + r) + attacker.Offset.Y));
} else if (!IsRenderingTargetOnSprite(Logic.Maps.MapHelper.ActiveMap,
attacker.X + s, attacker.Y + r))
{
destData.Blit(srfcMoveTargetTile, new Point(Screen.ScreenRenderer.ToTileX(attacker.X + s) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y + r) + attacker.Offset.Y));
}
else
{
destData.Blit(srfcMoveTargetTileHit, new Point(Screen.ScreenRenderer.ToTileX(attacker.X + s) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y + r) + attacker.Offset.Y));
stopattile = true;
}
if (stopattile)
{
break;
}
}
}
break;
case Enums.Direction.Up:
{
if (!Screen.ScreenRenderer.CanBeSeen(new Point(attacker.X, attacker.Y - r), Enums.MapID.Active)) {
destData.Blit(srfcMoveTargetTileDark, new Point(Screen.ScreenRenderer.ToTileX(attacker.X) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y - r) + attacker.Offset.Y));
} else if (!IsRenderingTargetOnSprite(Logic.Maps.MapHelper.ActiveMap,
attacker.X, attacker.Y - r))
{
destData.Blit(srfcMoveTargetTile, new Point(Screen.ScreenRenderer.ToTileX(attacker.X) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y - r) + attacker.Offset.Y));
}
else
{
destData.Blit(srfcMoveTargetTileHit, new Point(Screen.ScreenRenderer.ToTileX(attacker.X) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y - r) + attacker.Offset.Y));
stopattile = true;
}
if (stopattile)
{
break;
}
for (int s = 1; s <= r; s++)
{
if (!Screen.ScreenRenderer.CanBeSeen(new Point(attacker.X - s, attacker.Y - r), Enums.MapID.Active)) {
destData.Blit(srfcMoveTargetTileDark, new Point(Screen.ScreenRenderer.ToTileX(attacker.X - s) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y - r) + attacker.Offset.Y));
} else if (!IsRenderingTargetOnSprite(Logic.Maps.MapHelper.ActiveMap,
attacker.X - s, attacker.Y - r))
{
destData.Blit(srfcMoveTargetTile, new Point(Screen.ScreenRenderer.ToTileX(attacker.X - s) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y - r) + attacker.Offset.Y));
}
else
{
destData.Blit(srfcMoveTargetTileHit, new Point(Screen.ScreenRenderer.ToTileX(attacker.X - s) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y - r) + attacker.Offset.Y));
stopattile = true;
}
if (stopattile)
{
break;
}
if (!Screen.ScreenRenderer.CanBeSeen(new Point(attacker.X + s, attacker.Y - r), Enums.MapID.Active)) {
destData.Blit(srfcMoveTargetTileDark, new Point(Screen.ScreenRenderer.ToTileX(attacker.X + s) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y - r) + attacker.Offset.Y));
} else if (!IsRenderingTargetOnSprite(Logic.Maps.MapHelper.ActiveMap,
attacker.X + s, attacker.Y - r))
{
destData.Blit(srfcMoveTargetTile, new Point(Screen.ScreenRenderer.ToTileX(attacker.X + s) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y - r) + attacker.Offset.Y));
}
else
{
destData.Blit(srfcMoveTargetTileHit, new Point(Screen.ScreenRenderer.ToTileX(attacker.X + s) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y - r) + attacker.Offset.Y));
stopattile = true;
}
if (stopattile)
{
break;
}
}
}
break;
case Enums.Direction.Left:
{
if (!Screen.ScreenRenderer.CanBeSeen(new Point(attacker.X - r, attacker.Y), Enums.MapID.Active)) {
destData.Blit(srfcMoveTargetTileDark, new Point(Screen.ScreenRenderer.ToTileX(attacker.X - r) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y) + attacker.Offset.Y));
} else if (!IsRenderingTargetOnSprite(Logic.Maps.MapHelper.ActiveMap,
attacker.X - r, attacker.Y))
{
destData.Blit(srfcMoveTargetTile, new Point(Screen.ScreenRenderer.ToTileX(attacker.X - r) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y) + attacker.Offset.Y));
}
else
{
destData.Blit(srfcMoveTargetTileHit, new Point(Screen.ScreenRenderer.ToTileX(attacker.X - r) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y) + attacker.Offset.Y));
stopattile = true;
}
if (stopattile)
{
break;
}
for (int s = 1; s <= r; s++)
{
if (!Screen.ScreenRenderer.CanBeSeen(new Point(attacker.X - r, attacker.Y - s), Enums.MapID.Active)) {
destData.Blit(srfcMoveTargetTileDark, new Point(Screen.ScreenRenderer.ToTileX(attacker.X - r) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y - s) + attacker.Offset.Y));
} else if (!IsRenderingTargetOnSprite(Logic.Maps.MapHelper.ActiveMap,
attacker.X - r, attacker.Y - s))
{
destData.Blit(srfcMoveTargetTile, new Point(Screen.ScreenRenderer.ToTileX(attacker.X - r) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y - s) + attacker.Offset.Y));
}
else
{
destData.Blit(srfcMoveTargetTileHit, new Point(Screen.ScreenRenderer.ToTileX(attacker.X - r) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y - s) + attacker.Offset.Y));
stopattile = true;
}
if (stopattile)
{
break;
}
if (!Screen.ScreenRenderer.CanBeSeen(new Point(attacker.X - r, attacker.Y + s), Enums.MapID.Active)) {
destData.Blit(srfcMoveTargetTileDark, new Point(Screen.ScreenRenderer.ToTileX(attacker.X - r) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y + s) + attacker.Offset.Y));
} else if (!IsRenderingTargetOnSprite(Logic.Maps.MapHelper.ActiveMap,
attacker.X - r, attacker.Y + s))
{
destData.Blit(srfcMoveTargetTile, new Point(Screen.ScreenRenderer.ToTileX(attacker.X - r) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y + s) + attacker.Offset.Y));
}
else
{
destData.Blit(srfcMoveTargetTileHit, new Point(Screen.ScreenRenderer.ToTileX(attacker.X - r) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y + s) + attacker.Offset.Y));
stopattile = true;
}
if (stopattile)
{
break;
}
}
}
break;
case Enums.Direction.Right:
{
if (!Screen.ScreenRenderer.CanBeSeen(new Point(attacker.X + r, attacker.Y), Enums.MapID.Active)) {
destData.Blit(srfcMoveTargetTileDark, new Point(Screen.ScreenRenderer.ToTileX(attacker.X + r) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y) + attacker.Offset.Y));
} else if (!IsRenderingTargetOnSprite(Logic.Maps.MapHelper.ActiveMap,
attacker.X + r, attacker.Y))
{
destData.Blit(srfcMoveTargetTile, new Point(Screen.ScreenRenderer.ToTileX(attacker.X + r) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y) + attacker.Offset.Y));
}
else
{
destData.Blit(srfcMoveTargetTileHit, new Point(Screen.ScreenRenderer.ToTileX(attacker.X + r) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y) + attacker.Offset.Y));
stopattile = true;
}
if (stopattile)
{
break;
}
for (int s = 1; s <= r; s++)
{
if (!Screen.ScreenRenderer.CanBeSeen(new Point(attacker.X + r, attacker.Y - s), Enums.MapID.Active)) {
destData.Blit(srfcMoveTargetTileDark, new Point(Screen.ScreenRenderer.ToTileX(attacker.X + r) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y - s) + attacker.Offset.Y));
} else if (!IsRenderingTargetOnSprite(Logic.Maps.MapHelper.ActiveMap,
attacker.X + r, attacker.Y - s))
{
destData.Blit(srfcMoveTargetTile, new Point(Screen.ScreenRenderer.ToTileX(attacker.X + r) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y - s) + attacker.Offset.Y));
}
else
{
destData.Blit(srfcMoveTargetTileHit, new Point(Screen.ScreenRenderer.ToTileX(attacker.X + r) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y - s) + attacker.Offset.Y));
stopattile = true;
}
if (stopattile)
{
break;
}
if (!Screen.ScreenRenderer.CanBeSeen(new Point(attacker.X + r, attacker.Y + s), Enums.MapID.Active)) {
destData.Blit(srfcMoveTargetTileDark, new Point(Screen.ScreenRenderer.ToTileX(attacker.X + r) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y + s) + attacker.Offset.Y));
} else if (!IsRenderingTargetOnSprite(Logic.Maps.MapHelper.ActiveMap,
attacker.X + r, attacker.Y + s))
{
destData.Blit(srfcMoveTargetTile, new Point(Screen.ScreenRenderer.ToTileX(attacker.X + r) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y + s) + attacker.Offset.Y));
}
else
{
destData.Blit(srfcMoveTargetTileHit, new Point(Screen.ScreenRenderer.ToTileX(attacker.X + r) + attacker.Offset.X, Screen.ScreenRenderer.ToTileY(attacker.Y + s) + attacker.Offset.Y));
stopattile = true;
}
if (stopattile)
{
break;
}
}
}
break;
}
if (stopattile)
{
break;
}
}
#endregion
}
break;
}
}
/// <summary>
/// Adds a sprite to the QuadTree, meant to invoked by root node
/// </summary>
/// <param name="_sprite">Sprite to add</param>
internal void Add(Sprites.CollidableSprite _sprite)
{
List<Sprites.CollidableSprite> _sprites = new List<Sprites.CollidableSprite>();
_sprites.Add(_sprite);
Add(_sprites);
}
public override void Dispose()
{
running = false;
try
{
if (avgThread != null)
{
avgThread.Interrupt();
avgThread = null;
}
}
catch (Exception)
{
}
if (desktop != null)
{
desktop.Dispose();
desktop = null;
}
if (sprites != null)
{
sprites.Dispose();
sprites = null;
}
if (command != null)
{
command = null;
}
if (scrCG != null)
{
scrCG.Dispose();
scrCG = null;
}
if (dialog != null)
{
if (dialog.GetFileName() != null)
{
dialog.Destroy();
dialog = null;
}
}
base.Dispose();
}
private void InitDesktop()
{
if (desktop != null && sprites != null)
{
return;
}
this.desktop = new Desktop(this, GetWidth(), GetHeight());
this.sprites = new Sprites(GetWidth(), GetHeight());
if (dialog == null)
{
LImage tmp = LImage.CreateImage(GetWidth() - 20,
GetHeight() / 2 - 20, true);
LGraphics g = tmp.GetLGraphics();
g.SetColor(0, 0, 0, 125);
g.FillRect(0, 0, tmp.GetWidth(), tmp.GetHeight());
g.Dispose();
g = null;
dialog = new LTexture(GLLoader.GetTextureData(tmp));
if (tmp != null)
{
tmp.Dispose();
tmp = null;
}
}
this.message = new LMessage(dialog, 0, 0);
this.message.SetFontColor(LColor.white);
int size = message.GetWidth() / (message.GetMessageFont().GetSize());
if (LSystem.scaleWidth != 1 || LSystem.scaleHeight != 1)
{
if (size % 2 != 0)
{
size = size + 2;
}
else
{
size = size + 3;
}
}
else
{
if (size % 2 != 0)
{
size = size - 3;
}
else
{
size = size - 4;
}
}
this.message.SetMessageLength(size);
this.message.SetLocation((GetWidth() - message.GetWidth()) / 2,
GetHeight() - message.GetHeight() - 10);
this.message.SetVisible(false);
this.select = new LSelect(dialog, 0, 0);
this.select.SetLocation(message.X(), message.Y());
this.scrCG = new AVGCG();
this.desktop.Add(message);
this.desktop.Add(select);
this.select.SetVisible(false);
}
/// <summary>
/// Constructor, used to create root node
/// </summary>
/// <param name="_w">Width of node</param>
/// <param name="_h">Height of node</param>
/// <param name="_sprite">Sprite in node</param>
private Node(int _w, int _h, Sprites.CollidableSprite _sprite)
{
width = _w;
height = _h;
parent = null;
centerPoint = new Vector2(width / 2, height / 2);
subsections = null;
sprites = new Sprites.CollidableSprite[] { _sprite };
}
/// <summary>
/// Checks if the collide portion of a sprite is contained inside a subsection of current node
/// </summary>
/// <param name="_sprite">Sprite to check</param>
/// <returns>True if sprite is contained inside a subsection of current node</returns>
private bool InSubsection(Sprites.CollidableSprite _sprite)
{
return (_sprite.CollidablePosX < CenterX || _sprite.CollidableNegX > CenterX) &&
(_sprite.CollidablePosY < CenterY || _sprite.CollidableNegY > CenterY);
}
/// <summary>
/// Constructor, used to create root node
/// </summary>
/// <param name="_w">Width of node</param>
/// <param name="_h">Height of node</param>
/// <param name="_sprites">Sprites in node</param>
private Node(int _w, int _h, Sprites.CollidableSprite[] _sprites)
{
width = _w;
height = _h;
parent = null;
centerPoint = new Vector2(width / 2, height / 2);
subsections = null;
sprites = null;
PlaceSprites(new List<Sprites.CollidableSprite>(_sprites));
if (subsections != null)
Console.WriteLine("Root has subsections");
else
Console.WriteLine("Root does not have subsections");
}
void fetchComponents()
{
timeController = GameObject.FindGameObjectWithTag ("Time").GetComponent<TimeController>();
netPlay = GetComponentInParent<NetworkPlayer> ();
cam = GetComponentInParent<NetworkPlayer> ().playerCam;
sprites = GetComponentInParent<Sprites> ();
FleetsList = GameObject.FindGameObjectWithTag ("Lists").GetComponent<Lists> ().FleetsList;
}
//Setup_________________________________________________________________________________________________
void SetupGo(){
fleetGo = this.gameObject;
if (fleetGo == null) {
Debug.Log ("Fatal GameObject load error");
}
SpritesGo = GameObject.FindGameObjectWithTag ("GameController");
sprites = SpritesGo.GetComponent<Sprites>();
fleetSprite = sprites.FleetSprite;
if (fleetSprite == null) {
Debug.Log ("Fleet sprite load error");
}
fleetGo.transform.position.Set(position.x, position.y, position.z);
fleetGo.AddComponent<SpriteRenderer>();
selectionEffect = fleetGo.GetComponentInChildren<ParticleSystem> ();
SetGlow = false;
}
private void InitDesktop()
{
if (desktop != null && sprites != null)
{
return;
}
this.desktop = new Desktop(this, GetWidth(), GetHeight());
this.sprites = new Sprites(GetWidth(), GetHeight());
if (dialog == null)
{
LPixmap g = new LPixmap(GetWidth() - 20,
GetHeight() / 2 - 20, true);
g.SetAlphaValue(0, 0, 0, 125);
g.FillRect(0, 0, g.GetWidth(), g.GetHeight());
g.Dispose();
dialog = g.Texture;
g = null;
}
this.message = new LMessage(dialog, 0, 0);
this.message.SetFontColor(LColor.white);
int size = message.GetWidth() / (message.GetMessageFont().GetSize());
if (LSystem.scaleWidth != 1 || LSystem.scaleHeight != 1)
{
if (size % 2 != 0)
{
size = size + 2;
}
else
{
size = size + 3;
}
}
else
{
if (size % 2 != 0)
{
size = size - 3;
}
else
{
size = size - 4;
}
}
this.message.SetMessageLength(size);
this.message.SetLocation((GetWidth() - message.GetWidth()) / 2,
GetHeight() - message.GetHeight() - 10);
this.message.SetVisible(false);
this.select = new LSelect(dialog, 0, 0);
this.select.SetLocation(message.X(), message.Y());
this.scrCG = new AVGCG();
this.desktop.Add(message);
this.desktop.Add(select);
this.select.SetVisible(false);
}
public virtual void OnCreate(int width, int height)
{
this.mode = SCREEN_CANVAS_REPAINT;
this.baseInput = this;
this.width = width;
this.height = height;
this.halfWidth = width / 2;
this.halfHeight = height / 2;
this.touchX = touchY = lastTouchX = lastTouchY = touchDX = touchDY = 0;
this.isLoad = isLock = isClose = isTranslate = isGravity = false;
if (sprites != null)
{
sprites.Dispose();
sprites = null;
}
this.sprites = new Sprites(width, height);
if (desktop != null)
{
desktop.Dispose();
desktop = null;
}
this.desktop = new Desktop(baseInput, width, height);
this.isNext = true;
}
