void Start()
{
spriteRenderer = GetComponent <SpriteRenderer>();
//set Last sprite to None (Had nothing before)
lastSprite = SpriteType.None;
}
public void OnGUI()
{
activated = EditorGUILayout.Toggle("Activate", activated);
dic = (SpriteDictionary)EditorGUILayout.ObjectField("Sprite Dictionary", dic, typeof(SpriteDictionary), false);
if (dic == null)
{
SpriteDictionary[] dicArr = Resources.FindObjectsOfTypeAll <SpriteDictionary>();
if (dicArr != null && dicArr.Length > 0)
{
dic = dicArr[0];
}
}
type = (SpriteType)EditorGUILayout.EnumPopup("Type", type);
spriteLayer = (SpriteLayer)EditorGUILayout.EnumPopup("Layer", spriteLayer);
color = EditorGUILayout.ColorField(color);
baseScale = EditorGUILayout.FloatField("Base Scale", baseScale);
scaleDiffrence = EditorGUILayout.Slider("Scale Diffrence", scaleDiffrence, 0, 1);
seperateScaleAxis = EditorGUILayout.Toggle("Seperate Scale Axis", seperateScaleAxis);
rotation = EditorGUILayout.Slider("Rotation", rotation, 0, 360);
flipRandomX = EditorGUILayout.Toggle("Flip Random X", flipRandomX);
EditorGUILayout.MinMaxSlider("Distance", ref zMin, ref zMax, 0, 4);
if (zMax > 0)
{
spriteLayer = SpriteLayer.PERSPECTIVE_BACKGROUND;
}
}
public Monster(double x, double y, double width, double height,
int life, int giveLife, int takeLife, int defence, int expirience,
double speed, Vector2 direction, SpriteType spriteType, string name, int maxLife)
: base(x, y, width, height, life, giveLife, takeLife,
defence, expirience, speed, direction, spriteType, name, maxLife)
{
}
public void SetOverride(SpriteType type, int id, string file)
{
string targetFile = GetSpriteFilePathWithoutFallback(type, id).File;
Directory.CreateDirectory(Path.GetDirectoryName(targetFile));
File.Copy(file, targetFile, overwrite: true);
}
public override SpriteComponent GetComponentFromDefinition(Entity entity)
{
if (SpriteType == null)
{
throw new NullReferenceException("sprite type");
}
if (SpriteType.ToLower().Equals("static"))
{
if (Resource == null)
{
throw new NullReferenceException("static type, resource");
}
if (ResourceManager <Texture> .Get(Resource) is null)
{
ResourceManager <Texture> .Add(ResourceLoader.LoadTexture(Resource, TextureFilter.NEAREST));
}
return(new SpriteComponent
{
Value = new Renderable2D(new SharpDX.Vector2(Size[0], Size[1]), ResourceManager <Texture> .Get(Resource))
});
}
return(new SpriteComponent
{
Value = new Renderable2D(new SharpDX.Vector2(Size[0], Size[1]), 0xffff00ff)
});
}
public void switchSprite(SpriteType type)
{
if (image != null)
{
image.sprite = spriteArray[(int)type];
}
}
public void CreateSprite(SpriteType spriteType, Vector3 pos, Vector3 dir)
{
SpriteProp prop = GetProp(spriteType);
if (prop == null)
{
return;
}
SpriteBase sprite = null;
switch (prop.spriteType)
{
case SpriteType.BLOOD:
sprite = SpriteBlood.pool.Get();
(sprite as SpriteBlood).Init((int)prop.spriteType, prop.lifeTime, prop.materials[Random.Range(0, prop.materials.Length)],
pos, dir);
break;
case SpriteType.BLOOD_BIG:
sprite = SpriteBloodBig.pool.Get();
(sprite as SpriteBloodBig).Init((int)prop.spriteType, prop.lifeTime, prop.materials[Random.Range(0, prop.materials.Length)],
pos, dir, prop.scaleVal, prop.scaleTime);
break;
default:
break;
}
if (sprite != null)
{
_spriteMgr.Add(sprite);
}
}
private void Awake()
{
spriteType = SpriteType.shengjianjiyuan;
DontDestroyOnLoad(gameObject);
TextAsset textAsset = Resources.Load("Txt/setting", typeof(TextAsset)) as TextAsset;
if (textAsset != null)
{
string strSetting = textAsset.text;
GameSetting.SetSetting(strSetting);
}
if (Instance == null)
{
Instance = this;
}
else
{
Debug.LogError("Main instance already exists");
}
if (ResourcesManager.Instance == null)
{
gameObject.AddComponent <ResourcesManager>();
}
if (SceneManager.Instance == null)
{
gameObject.AddComponent <SceneManager>();
}
}
/// <summary>
/// zeichnet ein Sprite (mit Alpha-Kanal) in ein Bitmap
/// </summary>
/// <param name="target">Bild, wohin das Sprite gezeichnet werden soll</param>
/// <param name="fieldX">Feld X-Position</param>
/// <param name="fieldY">Feld Y-Position</param>
/// <param name="type">Typ des zu zeichnenden Sprites</param>
/// <param name="parts">Teile des Sprites</param>
public void BlitSprite(RawBitmap target, int fieldX, int fieldY, SpriteType type, SpriteParts parts = SpriteParts.All)
{
var targetRect = new RectInt(fieldX * spriteSize.w, fieldY * spriteSize.h, spriteSize.w, spriteSize.h);
int elY = (int)type / 7;
int elX = (int)type - (elY * 7);
var sourceRect = new RectInt(elX * spriteSize.w, elY * spriteSize.h, spriteSize.w, spriteSize.h);
switch (parts)
{
case SpriteParts.All: break;
case SpriteParts.Left: targetRect.w /= 2; sourceRect.w /= 2; break;
case SpriteParts.Right: targetRect.w /= 2; sourceRect.w /= 2; targetRect.x += spriteSize.w / 2; sourceRect.x += spriteSize.w / 2; break;
case SpriteParts.Top: targetRect.h /= 2; sourceRect.h /= 2; break;
case SpriteParts.Bottom: targetRect.h /= 2; sourceRect.h /= 2; targetRect.y += spriteSize.h / 2; sourceRect.y += spriteSize.h / 2; break;
case SpriteParts.TopLeft: targetRect.w /= 2; targetRect.h /= 2; sourceRect.w /= 2; sourceRect.h /= 2; break;
case SpriteParts.TopRight: targetRect.w /= 2; targetRect.h /= 2; sourceRect.w /= 2; sourceRect.h /= 2; targetRect.x += spriteSize.w / 2; sourceRect.x += spriteSize.w / 2; break;
case SpriteParts.BottomLeft: targetRect.w /= 2; targetRect.h /= 2; sourceRect.w /= 2; sourceRect.h /= 2; targetRect.y += spriteSize.h / 2; sourceRect.y += spriteSize.h / 2; break;
case SpriteParts.BottomRight: targetRect.w /= 2; targetRect.h /= 2; sourceRect.w /= 2; sourceRect.h /= 2; targetRect.x += spriteSize.w / 2; sourceRect.x += spriteSize.w / 2; targetRect.y += spriteSize.h / 2; sourceRect.y += spriteSize.h / 2; break;
default: throw new Exception("unknown parts: " + (int)parts);
}
if (type == SpriteType.Empty)
{
target.FillRectangle(targetRect.x, targetRect.y, targetRect.w, targetRect.h, 0x001122);
}
target.BlitAlpha(targetRect.x, targetRect.y, spriteBitmap, sourceRect);
}
/// <summary>
/// General function to try to equip the item in the active hand
/// </summary>
public void Equip()
{
// Is the player allowed to interact? (not a ghost)
if (!isValidPlayer())
{
return;
}
// Is there an item to equip?
if (!CurrentSlot.IsFull)
{
return;
}
//This checks which UI slot the item can be equiped to and swaps it there
ItemType type = Slots.GetItemType(CurrentSlot.Item);
SpriteType masterType = Slots.GetItemMasterType(CurrentSlot.Item);
UI_ItemSlot itemSlot = InventorySlotCache.GetSlotByItemType(CurrentSlot.Item);
if (itemSlot != null)
{
SwapItem(itemSlot);
}
else
{
Logger.LogError("No slot type was found for this object for auto equip", Category.UI);
}
}
public SpriteFile(SpriteType type, int id, string file, bool isOverride)
{
Type = type;
Id = id;
File = file;
IsOverride = isOverride;
}
public AnimSprite(SpriteType spriteType, int framesCount, int frameWidth, int frameHeight)
{
FrameHeight = frameHeight;
FrameWidth = frameWidth;
_framesCount = framesCount ;
SpriteType = spriteType;
}
public SpriteState(string name, Vector3 pos, float alpha)
{
spriteName = name;
type = SpriteType.Normal;
SetPosition(pos);
spriteAlpha = alpha;
}
public ProxyLetterSprite(SpriteType name, Image image, Sprite realSprite)
: base(name)
{
this.realSprite = realSprite;
this.image = image;
setScale(1, 1);
}
public void StartUseMoly(SpriteType spriteType = SpriteType.Ppo,
float waitTime = 0.5f)
{
//idle이 아닐 때 실행 종료.
if (nowMolyState != MolyState.idle)
{
return;
}
//두더지 대기시간
waitTimeFact = waitTime;
nowMolySpriteType = spriteType;
//두더지 스프라이트 변경.
switch (spriteType)
{
case SpriteType.Ppo:
molySprite.spriteName = "ppo";
break;
case SpriteType.Ppu:
molySprite.spriteName = "ppu";
break;
}
molySprite.MakePixelPerfect();
//두더지 아래에서 위로 움직이게 설정.
MolyMove(true);
}
public static GameObject BuildCharacterEntity(
Game1 game,
int playerNumber,
Color playerColor,
Vector2 position,
float rotation,
Vector2 scale,
float maxGroundSpeed,
float maxAirSpeed,
SpriteType spriteType,
List<Shape> boundingBoxes,
Dictionary<ActionDefinition, ActionInfo> actionsInformationList)
{
GameObject entity = DynamicEntityFactory.BuildDynamicEntity(game, position, rotation, scale, maxGroundSpeed, maxAirSpeed, spriteType, boundingBoxes);
PlayerComponent playerComponent = new PlayerComponent(entity, playerNumber);
HealthComponent healthComponent = new HealthComponent(entity);
ColorComponent colorComponent = new ColorComponent(entity, playerColor);
CurrentActionComponent curActionComponent = (CurrentActionComponent)entity.GetComponent(ComponentType.Action);
curActionComponent.SetActionInfoList(actionsInformationList);
entity.AddComponent(playerComponent);
entity.AddComponent(healthComponent);
entity.AddComponent(colorComponent);
return entity;
}
public List <SpriteFile> GetAllSpriteFiles(SpriteType type)
{
if (!_fallbackSpriteProvider.IsDefaultsPopulated)
{
return(new List <SpriteFile>());
}
var dict = new Dictionary <SpriteType, Dictionary <int, SpriteFile> >();
foreach (var i in _fallbackSpriteProvider.GetAllSpriteFiles(type))
{
if (!dict.TryGetValue(i.Type, out Dictionary <int, SpriteFile> subDict))
{
subDict = new Dictionary <int, SpriteFile>();
dict[i.Type] = subDict;
}
subDict[i.Id] = i;
}
string overrideFolder = Path.Combine(_mod.FolderPath, GraphicsInfoResource.Get(type).PngFolder);
if (Directory.Exists(overrideFolder))
{
foreach (var i in Directory.GetFiles(overrideFolder)
.Select(i => new SpriteFile(type: type, id: int.Parse(Path.GetFileNameWithoutExtension(i)), file: i, isOverride: true)))
{
dict[i.Type][i.Id] = i;
}
}
return(dict.Values.SelectMany(i => i.Values).ToList());
}
public static Sprite GetSprite(SpriteType spriteType,
string name,
bool warnOnFail = true)
{
if (!allSpritesLoaded)
{
Debug.LogWarning("Sprites weren't automatically loaded, loading now");
LoadAllSprites();
}
if (sprites.ContainsKey(spriteType))
{
if (sprites[spriteType].ContainsKey(name))
{
return(sprites[spriteType][name]);
}
else
{
if (warnOnFail)
{
Debug.LogWarning("Couldn't find sprite name - " + name);
}
return(null);
}
}
else
{
if (warnOnFail)
{
Debug.LogError("Invalid spriteType - " + spriteType);
}
return(null);
}
}
public void Attack()
{
if (ST < CurrentWeapon.STReq / 5)
{
return;
}
if (IsJumping)
{
return;
}
if (CurrentSprite == SpriteType.Dodge || CurrentSprite == SpriteType.Attack || CurrentSprite == SpriteType.Hitted || CurrentSprite == SpriteType.Healing)
{
PreviousSprite = SpriteType.Attack;
return;
}
State = 0;
CurrentInterval = 0;
HorizontalDirection = 0;
PreviousSprite = CurrentSprite;
PreviousDirection = CurrentDirection;
CurrentSprite = SpriteType.Attack;
ST -= CurrentWeapon.STReq;
if (ST < 0)
{
ST = 0;
}
}
internal void CalculateBoundingBox()
{
// update the sprite bounding box
var halfSpriteSize = Sprite?.Size / 2 ?? Vector2.Zero;
// Only calculate if we've changed...
if (lastWorldMatrix != WorldMatrix || lastHalfSpriteSize != halfSpriteSize || lastSpriteType != SpriteType)
{
Vector3 halfBoxSize;
var boxWorldPosition = WorldMatrix.TranslationVector;
if (SpriteType == SpriteType.Billboard)
{
// Make a gross estimation here as we don't have access to the camera view matrix
// TODO: move this code or grant camera view matrix access to this processor
var maxScale = Math.Max(WorldMatrix.Row1.Length(), Math.Max(WorldMatrix.Row2.Length(), WorldMatrix.Row3.Length()));
halfBoxSize = maxScale * halfSpriteSize.Length() * Vector3.One;
}
else
{
halfBoxSize = new Vector3(
Math.Abs(WorldMatrix.M11 * halfSpriteSize.X) + Math.Abs(WorldMatrix.M21 * halfSpriteSize.Y),
Math.Abs(WorldMatrix.M12 * halfSpriteSize.X) + Math.Abs(WorldMatrix.M22 * halfSpriteSize.Y),
Math.Abs(WorldMatrix.M13 * halfSpriteSize.X) + Math.Abs(WorldMatrix.M23 * halfSpriteSize.Y));
}
// Update bounding box
BoundingBox = new BoundingBoxExt(boxWorldPosition - halfBoxSize, boxWorldPosition + halfBoxSize);
// Save current state for next check
lastWorldMatrix = WorldMatrix;
lastHalfSpriteSize = halfSpriteSize;
lastSpriteType = SpriteType;
}
}
public static string GetRelativeSpritePath(SpriteType type, int id)
{
string idString = id.ToString().PadLeft(4, '0');
string dir = GraphicsInfoResource.Get(type).PngFolder;
return(Path.Combine(dir, idString + ".png"));
}
public Image getImage(SpriteType name)
{
switch (name)
{
case SpriteType.Bug:
return(ImageFactoryBug.Instance.getImage(0));
case SpriteType.Crab:
return(ImageFactoryCrab.Instance.getImage(0));
case SpriteType.Squid:
return(ImageFactorySquid.Instance.getImage(0));
case SpriteType.Player:
return(ImageFactoryPlayer.InstancePlayer.getImage(0));
case SpriteType.PlayerProjectile:
return(ImageFactoryShield.Instance.getImage(0));
case SpriteType.EnemyProjectile:
return(ImageFactoryShield.Instance.getImage(0));
case SpriteType.Shield:
return(ImageFactoryShield.Instance.getImage(0));
case SpriteType.UFO:
return(ImageFactoryUFO.Instance.getImage(0));
case SpriteType.Explosion:
return(ImageFactoryExplosion.InstancePlayer.getImage(0));
default:
return(ImageFactoryBug.Instance.getImage(0));
}
}
// Use this for initialization
void Start()
{
//Le asignamos a nuestra variable rend un componente de tipo Sprite Renderer
rend = GetComponent <SpriteRenderer>();
//a la variable ultimoElemento le asignamos el valor face1 de nuestro enum.
ultimoElemento = SpriteType.face1;
}
public GameObject MakeSprite(SpriteType spriteType, int row, int col)
{
string name = "";
string layerName = "";
switch (spriteType) {
case SpriteType.Wall:
name = "Wall";
layerName = "Stage";
break;
case SpriteType.Floor:
name = "Floor";
layerName = "Stage";
break;
case SpriteType.Target:
name = "Target";
layerName = "Stage";
break;
case SpriteType.Box:
name = "Box";
layerName = "Object";
break;
default:
Assert.IsTrue(false);
break;
}
var obj = new GameObject(name);
obj.AddComponent<SpriteRenderer>().sprite = GetSprite(spriteType);
obj.GetComponent<SpriteRenderer>().sortingLayerName = layerName;
const float size = Stage.SpriteSize;
obj.transform.position = new Vector3(size * col, -size * row, 0);
return obj;
}
public void Dodge()
{
if (ST < DodgeST / 5)
{
return;
}
if (CurrentSprite == SpriteType.Attack || CurrentSprite == SpriteType.Hitted || CurrentSprite == SpriteType.Healing)
{
PreviousSprite = SpriteType.Dodge;
return;
}
if (CurrentSprite == SpriteType.Walk)
{
PreviousSprite = SpriteType.Walk;
}
else
{
PreviousSprite = SpriteType.Stand;
}
PreviousDirection = CurrentDirection;
CurrentSprite = SpriteType.Dodge;
State = 0;
HorizontalDirection = CurrentDirection == Direction.Right ? 1 : -1;
Speed = 25;
IsImmortal = true;
ST -= DodgeST;
if (ST < 0)
{
ST = 0;
}
}
public void SpeedUp(int dir)
{
if (CurrentSprite == SpriteType.Walk && dir == 0)
{
if (MyForm.IsLeft && CurrentDirection == Direction.Right)
{
CurrentDirection = Direction.Left;
HorizontalDirection = -1;
}
else if (MyForm.IsRight && CurrentDirection == Direction.Left)
{
CurrentDirection = Direction.Right;
HorizontalDirection = 1;
}
else if ((MyForm.IsLeft && CurrentDirection == Direction.Left) || (MyForm.IsRight && CurrentDirection == Direction.Right))
{
}
else
{
HorizontalDirection = 0;
CurrentSprite = SpriteType.Stand;
}
}
else if (CurrentSprite == SpriteType.Attack || CurrentSprite == SpriteType.Dodge || CurrentSprite == SpriteType.Hitted || CurrentSprite == SpriteType.Healing)
{
PreviousSprite = dir == 0 ? SpriteType.Stand : SpriteType.Walk;
PreviousDirection = dir == 0 ? CurrentDirection : (dir < 0 ? Direction.Left : Direction.Right);
}
else
{
CurrentDirection = dir != 0 ? (dir > 0 ? Direction.Right : Direction.Left) : CurrentDirection;
HorizontalDirection = dir;
CurrentSprite = dir == 0 ? SpriteType.Stand : SpriteType.Walk;
}
}
public static AnimatedTexture Create(SpriteType type,int gridColumn, int gridRow)
{
var sprite = new AnimatedTexture();
sprite.LoadContent(s_assetHandler,type);
sprite.SetPosition(gridColumn, gridRow);
return sprite;
}
// API
public static Result CreateSprite(VoxelData voxelData, int modelIndex, SpriteType type, int num, float light, Vector3 pivot, Camera screenShotCamera, float cameraScale)
{
// Voxels
Voxel[,,] voxels = GetVoxels(voxelData, modelIndex);
// Colorss
int[] widths;
int[] heights;
Color[][] colorss;
Result result;
switch (type)
{
default:
case SpriteType._25D:
num = Mathf.Clamp(num, 1, 8);
light = Mathf.Clamp01(light);
colorss = Get25DColorss(
voxels, voxelData.Palette.ToArray(), screenShotCamera,
num, light, cameraScale,
out widths, out heights
);
result = PackTextures(colorss, widths, heights, pivot);
result.NameFixes = new string[result.Rects.Length];
for (int i = 0; i < result.Rects.Length; i++)
{
result.NameFixes[i] = SPRITE_ANGLE[i].ToString("0");
}
break;
case SpriteType._8bit:
num = Mathf.Clamp(num, 1, 8);
light = Mathf.Clamp01(light);
colorss = Get8bitColorss(
voxels, voxelData.Palette.ToArray(),
num, light,
out widths, out heights
);
result = PackTextures(colorss, widths, heights, pivot);
result.NameFixes = new string[result.Rects.Length];
for (int i = 0; i < result.Rects.Length; i++)
{
result.NameFixes[i] = SPRITE_ANGLE[i].ToString("0");
}
break;
case SpriteType._2D:
num = Mathf.Clamp(num, 1, 6);
light = Mathf.Clamp01(light);
colorss = Get2DColorss(voxels, voxelData.Palette.ToArray(), num, light, out widths, out heights);
result = Pack2DTextures(colorss, widths, heights, pivot);
result.NameFixes = new string[result.Rects.Length];
for (int i = 0; i < result.Rects.Length; i++)
{
result.NameFixes[i] = SPRITE_2D_NAMES[i];
}
break;
}
return(result);
}
public AnimationManager(ImageManager iManager, Sprite sprite, SpriteType name)
{
this.iManager = iManager;
this.sprite = sprite;
this.name = name;
totalImages = iManager.getTotalImages();
}
/// <summary>
/// Create a new animated sprite
/// </summary>
/// <param name="spriteName">key used to find sprite data in SpriteData Dictionary</param>
public Sprite(string spriteName, SpriteType type = SpriteType.None)
{
SpriteData spriteData = Data[spriteName];
_frameWidth = spriteData.FrameWidth;
_frameHeight = spriteData.FrameHeight;
_textureCenter = new Vector2(_frameWidth / 2.0f, _frameHeight / 2.0f);
_framesPerAnimation = spriteData.NumFrames;
_numStates = spriteData.NumStates;
_defaultScale = spriteData.DefaultScale;
ScaleFactor = 1.0f; //use property to set rect
_animationInterval = TimeSpan.FromSeconds(spriteData.SecondsPerAnimation);
_timeTillNext = _animationInterval;
initRects();
Shade = Color.White;
_zLayer = spriteData.ZLayer;
switch (type)
{
case SpriteType.Projectile:
_spriteSheet = Content.Load <Texture2D>(c_projectileSpritePath + spriteData.AssetName);
break;
case SpriteType.Unit:
_spriteSheet = Content.Load <Texture2D>(c_unitSpritePath + spriteData.AssetName);
break;
default:
_spriteSheet = Content.Load <Texture2D>(c_SpritePath + spriteData.AssetName);
break;
}
}
private void CombineBitmapByFolder(List <string> directories, SpriteType spriteType, string imagePath)
{
foreach (string directory in directories)
{
string[] images = Directory.GetFiles(directory, "*.png", SearchOption.TopDirectoryOnly);
if (images.Length > 1)
{
bool compressed = chkCompress.Checked;
string imageName;
string temp;
imageName = temp = Path.GetFileName(directory);
string imageUncompressedName = string.Format("{0}_uncompressed.png", imageName);;
imageName = compressed ? imageUncompressedName : string.Format("{0}.png", imageName);
string rootDirectory = Path.GetDirectoryName(imagePath);
if (!rootDirectory.EndsWith(@"\"))
{
rootDirectory += @"\";
}
string newDir = Path.Combine(path, directory.Replace(rootDirectory, string.Empty));
Bitmap mergedImage = CombineBitmap(images, spriteType, temp, newDir);
mergedImage.Save(string.Format("{0}\\{1}", newDir, imageName));
mergedImage.Save(string.Format("{0}\\{1}", path, imageName));
if (compressed)
{
CompressImgae();
}
}
}
ConvertToOne(imagePath);
MessageBox.Show("The sprite image and style have been generated successfully! :)", "successful", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
public override void notifyCollisionType(SpriteType name)
{
if (name == SpriteType.Victory)
{
//controller.setState(GameMode.Start);
GameControllerFactory.getFactory.c.setState(GameMode.Start);
}
}
public Sprite(float scale, Texture2D texture, Vector2 position, SpriteType spriteType = SpriteType.TEST)
{
this.ScaleFactor = scale;
this.texture = texture;
this.position = position;
this.spriteType = spriteType;
this.gravity = true;
}
public Background()
{
SizeX = 1280;
SizeY = 720;
X = 0;
Y = 0;
SpriteType = SpriteType.Background;
}
private void SetSprite(SpriteType spriteType, Sprite sprite)
{
Image image = images[spriteType];
image.enabled = sprite != null;
image.sprite = sprite;
}
public MySprite AddSprite(SpriteType type = SpriteType.TEXTURE, string data = null, Vector2?position = null, Vector2?size = null, Color?color = null, string fontId = null, TextAlignment alignment = TextAlignment.LEFT, float rotation = 0)
{
MySprite sprite = new MySprite(type, data, position, size, color, fontId, alignment, rotation);
// Add the sprite to the frame
frame.Add(sprite);
return(sprite);
}
public SpriteContent(Texture2D texture, Rectangle gridSize, int frames, int gridWidth, int gridHeight)
: this(texture)
{
this.texture = texture;
this.framesCount = frames;
this.spriteType = SpriteType.GridSpriteSheet;
initializeGridSpriteRects(gridSize, frames, gridWidth, gridHeight);
}
/// <summary>
/// Shape constructor.
/// </summary>
/// <param name="contentManager">The content manager.</param>
public SpriteBase(ContentManager contentManager, SpriteType spriteType, int spriteWidth)
{
// set the sprite type
CurrentSpriteType = spriteType;
// set the stable size of the draw rectangle
// (so that we can shrink and re-grow during a shape-shift)
normalWidth = spriteWidth;
}
/// <summary>
/// Shape constructor.
/// </summary>
/// <param name="contentManager">The content manager.</param>
public Shape(ContentManager contentManager, SpriteType spriteType, int spriteWidth)
: base(contentManager, spriteType, spriteWidth)
{
// load sprites
LoadContent(contentManager);
// create the source rectangle for the sprite strip
sourceRectangle = new Rectangle(0, 0, BASE_WIDTH, BASE_WIDTH);
}
/// <summary>
/// Mouth constructor.
/// </summary>
/// <param name="contentManager">The content manager.</param>
public Mouth(ContentManager contentManager, SpriteType spriteType, int spriteWidth)
: base(contentManager, spriteType, spriteWidth)
{
// load the sprite image
LoadContent(contentManager);
// define the animation strip rectangle
sourceRectangle = new Rectangle(0, 0, BASE_WIDTH, BASE_WIDTH);
}
public void AddSprite(SpriteType type, String location, int posx, int posy, int offx, int offy, float sx, float sy)
{
Entity entity = new Entity(Entity.EntityType.LIFE_BAR, type.ToString());
entity.AddSprite(Animation.State.NONE, location, true);
entity.SetPostion(posx, posy, 0);
entity.SetOffset(Animation.State.NONE, offx, offy);
entity.SetScale(sx, sy);
sprites.Add(type, entity);
}
private static List<SpriteType> findSpriteTypesFromBitmask(SpriteType bitmaskedSpriteType)
{
var resultList = new List<SpriteType>();
for (int i = 0; i < spriteTypes.Length; i++)
{
var spriteType = spriteTypes[i];
if ((bitmaskedSpriteType & spriteType) == spriteType)
resultList.Add(spriteType);
}
return resultList;
}
public void LoadContent(ContentManager assetHandler,SpriteType assetName)
{
if (m_contentManager == null)
{
m_contentManager = assetHandler;
m_graphic = assetHandler.Load<Texture2D>(m_assetPath);
m_spriteInfo = SpriteSheetManager.GetSpriteInfo(assetName);
m_currentFrame = 0;
m_animationTimer = m_ANIMATE_SPEED;
}
}
public static void Draw(SpriteType bitmaskedSpriteType, SpriteBatch spriteBatch)
{
var relevantSpriteTypes = findSpriteTypesFromBitmask(bitmaskedSpriteType);
for (int i = 0; i < relevantSpriteTypes.Count; i++)
{
var spriteType = relevantSpriteTypes[i];
var count = _sprites[spriteType].Count;
for (int j = 0; j < count; j++)
_sprites[spriteType][j].Draw(spriteBatch);
}
}
public static void Update(SpriteType bitmaskedSpriteType, float elapsedTime)
{
var relevantSpriteTypes = findSpriteTypesFromBitmask(bitmaskedSpriteType);
for (int i = 0; i < relevantSpriteTypes.Count; i++)
{
var spriteType = relevantSpriteTypes[i];
var count = _sprites[spriteType].Count;
for (int j = count - 1; j >= 0; j--)
_sprites[spriteType][j].Update(elapsedTime);
}
}
public GameplayObject GetTileOfType(SpriteType type)
{
foreach (GameplayObject item in m_drawableComponents)
{
if (item.GetAssetType() == type && item.IsActive())
{
return item;
}
}
return null;
}
/// <summary>
/// Eyes constructor.
/// </summary>
/// <param name="contentManager">The content manager.</param>
public Eyes(ContentManager contentManager, SpriteType spriteType, int spriteWidth)
: base(contentManager, spriteType, spriteWidth)
{
// load sprite content
LoadContent(contentManager);
// define the animation strip rectangle
sourceRectangle = new Rectangle(0, 0, BASE_WIDTH, BASE_WIDTH);
// needed for the flip effect
spriteOrigin = new Vector2(0, 0);
}
public static void CheckCollisionsBetween(SpriteType spriteType, SpriteType otherSpriteType)
{
var sprites = _sprites[spriteType];
var otherSprites = _sprites[otherSpriteType];
for (var i = sprites.Count - 1; i >= 0; i--)
{
for (var j = otherSprites.Count - 1; j >= 0; j--)
{
if(sprites[i].doesCollideWith(otherSprites[j]))
sprites[i].handleCollisionWith(otherSprites[j]);
}
}
}
public Sprite displaySprite(GameObject currentSpriteNumber, Image statusIcon, Image priceIcon, Sprite sprite, Sprite[] sprites, SpriteType spriteType)
{
display2CharNumber(currentSpriteNumber, number(sprite, sprites));
statusIcon.sprite = statusSprite(sprite, spriteType);
if (statusIcon.sprite.Equals(notOwned)) {
priceIcon.sprite = priceSprite(sprite, sprites);
if (!SettingsController.Instance.checkFunds(price(sprite, sprites))) {
statusIcon.sprite = needCoins;
}
} else {
priceIcon.sprite = nullIcon;
}
//change neighbors
return sprite;
}
public Sprite buy(GameObject currentSpriteNumber, Image statusIcon, Image priceIcon, Sprite currentSprite, Sprite[] sprites, SpriteType spriteType)
{
int price = SpriteService.Instance.price(currentSprite, sprites);
SpriteStatus status = getStatus(currentSprite, spriteType);
if (status.Equals(SpriteStatus.NOT_OWNED) && SettingsController.Instance.checkFunds(price)) {
SettingsController.Instance.setCoins(SettingsController.Instance.getCoins() - price);
display4CharNumber(coinsTotal, SettingsController.Instance.getCoins());
spriteDao.setStatus(currentSprite, (int) SpriteStatus.OWNED);
SettingsController.Instance.removeFromNotOwnedSprites(currentSprite);
MusicController.Instance.playCoin();
} else if (status.Equals(SpriteStatus.OWNED)) {
select(currentSprite, spriteType);
}
return displaySprite(currentSpriteNumber, statusIcon, priceIcon, currentSprite, sprites, spriteType);
}
protected Creature(Position position, ObjectSize size,
SpriteType spriteType)
: base(position, size, spriteType)
{
Properties = new Dictionary<Property, dynamic>()
{
{Property.MaxHealthPoints, null},
{Property.HealthPoints, null},
{Property.DefensePoints, null},
{Property.AttackPoints, null},
{Property.AttackRange, null},
{Property.IsAlive, true},
{Property.MovementSpeed, null},
{Property.WeaponHeld, null}
};
}
private Sprite GetSprite(SpriteType spriteType)
{
string name = "";
switch (spriteType) {
case SpriteType.Wall: name = "spWall"; break;
case SpriteType.Floor: name = "spFloor"; break;
case SpriteType.Target: name = "spTarget"; break;
case SpriteType.Box: name = "spBox"; break;
case SpriteType.PlayerN: name = "spPlayerN"; break;
case SpriteType.PlayerS: name = "spPlayerS"; break;
case SpriteType.PlayerW: name = "spPlayerW"; break;
case SpriteType.PlayerE: name = "spPlayerE"; break;
}
Sprite[] sprites = Resources.LoadAll<Sprite>("sokoban");
return sprites.Where(e => e.name == name).First();
}
public static GameplayObject Create(SpriteType type, int gridColumn, int gridRow)
{
switch (type)
{
case SpriteType.CRATE:
return new Crate(gridColumn, gridRow);
case SpriteType.PLAYER_STAND:
return new HumanPlayer(gridColumn, gridRow, s_playerCount++);
case SpriteType.PLAYER_WALK:
return new ComputerPlayer(gridRow, gridColumn);
case SpriteType.WALL:
return new Wall(gridColumn, gridRow);
case SpriteType.DIRT_FLOOR:
return new EnvironmentTile(gridColumn, gridRow,SpriteType.DIRT_FLOOR);
default:
throw new Exception("An undefined SpriteType case was passed into the GameplayObjectFactory.");
}
}
public PlayerObject(Game1 game, int playerNum, SpriteType type)
: base(game)
{
Transform2DComponent transformComponent = new Transform2DComponent(
this,
new Vector2(300,100),
0.0f,
new Vector2(1.0f));
this.AddComponent(transformComponent);
this.AddComponent(new PlayerComponent(this, playerNum));
this.AddComponent(new CurrentActionComponent(
this,
new ActionComponent(DirectionalAction.Left, SecondaryAction.Stand, PrimaryAction.None),
new Dictionary<ActionDefinition, ActionInfo>()
));
this.AddComponent(new SpriteComponent(this, type, game));
}
/// <summary>
/// Character constructor.
/// </summary>
/// <param name="contentManager">The content manager.</param>
/// <param name="x">The center x position.</param>
/// <param name="y">The center y position.</param>
/// <param name="width">The width of the sprite.</param>
/// <param name="height">The height of the sprite.</param>
/// <param name="windowWidth">The window width (needed for the boundaries).</param>
/// <param name="windowHeight">The window height (needed for the boundaries).</param>
public Character(ContentManager contentManager, SpriteType spriteType, int x, int y, int width,
int height, int windowWidth, int windowHeight)
{
// define the position vector and rectangle
positionVector = new Vector2(x - width / 2, y - width / 2);
positionRectangle = new Rectangle(x - width / 2, y - height / 2, width, height);
// set boundaries for characters
boundaryBottom = windowHeight;
boundaryRight = windowWidth;
// create the shape object
shape = new Shape(contentManager, spriteType, width);
eyes = new Eyes(contentManager, spriteType, width);
mouth = new Mouth(contentManager, spriteType, width);
// set the sprite type
CurrentSpriteType = spriteType;
// Active characters
IsActive = true;
}
public void StartUseMoly(SpriteType spriteType=SpriteType.Ppo,
float waitTime = 0.5f)
{
//idle이 아닐 때 실행 종료.
if( nowMolyState != MolyState.idle) return;
//두더지 대기시간
waitTimeFact = waitTime;
nowMolySpriteType = spriteType;
//두더지 스프라이트 변경.
switch(spriteType)
{
case SpriteType.Ppo:
molySprite.spriteName = "ppo";
break;
case SpriteType.Ppu:
molySprite.spriteName = "ppu";
break;
}
molySprite.MakePixelPerfect();
//두더지 아래에서 위로 움직이게 설정.
MolyMove(true);
}
public static KeyValuePair<SpriteType[, ], SpriteType> Load()
{
SpriteType[,] data = new SpriteType[SpriteSheetManager.Columns, SpriteSheetManager.Rows];
SpriteType backgroundTile = SpriteType.EMPTY;
if (File.Exists("save.dat"))
{
TextReader input = new StreamReader("save.dat");
string saveData = input.ReadLine();
string[] explodedSaveData = saveData.Split(',');
for (int ii = 0; ii < SpriteSheetManager.Columns; ii++)
{
for (int jj = 0; jj < SpriteSheetManager.Rows; jj++)
{
data[ii, jj] = SpriteType.EMPTY;
}
}
for (int ii = 0; ii < explodedSaveData.Count() - 1; ii += 3)
{
foreach (SpriteType item in Enum.GetValues(typeof(SpriteType)))
{
if (item.ToString() == explodedSaveData[ii + 2])
{
if (int.Parse(explodedSaveData[ii]) == -1)
{
backgroundTile = item;
}
else
{
data[int.Parse(explodedSaveData[ii]), int.Parse(explodedSaveData[ii + 1])] = item;
}
}
}
}
}
return new KeyValuePair<SpriteType[,],SpriteType>(data,backgroundTile);
}
public Game1()
{
graphics = new GraphicsDeviceManager(this);
Content.RootDirectory = "Content";
this._systems = new List<GameSystem>();
this._objects = new List<GameObject>();
this._services = new Dictionary<string, GameSystem>();
this._systemsCallOrder = new List<int>();
this.curScreen = ScreenType.Start;
this.graphics.PreferredBackBufferWidth = 1200;
this.graphics.PreferredBackBufferHeight = 800;
this.graphics.ApplyChanges();
this.CurrentPathfindingGraph = new AStarGraph(this, new List<AStarNode>());
this.play1 = SpriteType.None;
this.play2 = SpriteType.None;
this.winner = 0;
this.playe1 = PlayerType.None;
this.playe2 = PlayerType.None;
gameType = GameTypes.None;
LivesOrTime = 0;
this.mapType = MapType.Basic;
this.Winner = null;
}
public static bool HasTileType(Vector2 location,SpriteType assetType)
{
return s_board[(int)location.X, (int)location.Y].IsTypeRegistered(assetType);
}
public static bool HasTileType(int gridColumn,int gridRow, SpriteType assetType)
{
return s_board[gridColumn, gridRow].IsTypeRegistered(assetType);
}
