protected override void caneEffect(MyCharacterController user, ObjectEntity target)
{
MyCharacterController c = target as MyCharacterController;
if (c != null) {
GameController.FieldActionController.objectBullRush(user, c, BasisParameter.BullRushDistance, BasisParameter.EffectPoint);
}
}
public MenuEntity(Game game, string id, Vector2 position, Vector2 size)
: base(game, id, position)
{
CanCollide = false;
ResumeButton = new ResumeButtonEntity(Game, "ResumeButton", Vector2.Zero, Game.AssetManager.GetTexture("buttonResume"));
Minus = new VolumeButtonEntity(Game, "MinusButton", new Vector2(0F, ResumeButton.Position.Y + ResumeButton.Size.Y + 10F), Game.AssetManager.GetTexture("buttonMinus"), -0.1F);
Volume = new TextureEntity(Game, "Volume", new Vector2(Minus.Position.X + Minus.Size.X + 10F, Minus.Position.Y), Game.AssetManager.GetTexture("buttonVolume"));
Plus = new VolumeButtonEntity(Game, "PlusButton", new Vector2(Volume.Position.X + Volume.Size.X + 10F, Minus.Position.Y), Game.AssetManager.GetTexture("buttonPlus"), 0.1F);
Multiplayer = new MultiplayerButtonEntity(Game, "Multiplayer", new Vector2(0F, Minus.Position.Y + Minus.Size.Y + 20F), Game.AssetManager.GetTexture("buttonMultiplayer"));
ExitButton = new ExitButtonEntity(Game, "ExitButton", new Vector2(0F, Multiplayer.Position.Y + Multiplayer.Size.Y + 20F), Game.AssetManager.GetTexture("buttonExit"));
VolumePercentage = new TextEntity(Game, "VolumePercentage", Vector2.Zero, "100%");
ResumeButton.CanCollide = false;
Minus.CanCollide = false;
Volume.CanCollide = false;
Plus.CanCollide = false;
Multiplayer.CanCollide = false;
ExitButton.CanCollide = false;
VolumePercentage.CanCollide = false;
AddChild(ResumeButton);
AddChild(Minus);
AddChild(Volume);
AddChild(Plus);
AddChild(Multiplayer);
AddChild(ExitButton);
AddChild(VolumePercentage);
}
/// <inheritdoc/>
protected override async Task <ObjectModel> ProtectedHandleAsync(CreateObjectCommand request, CancellationToken cancellationToken)
{
context.BeginTransaction();
// TODO: support custom extensions
string fileExtension = fileSystem.Path.GetExtension(request.OriginalFilename);
Guid guid = idGenService.CreateId();
string path = fileSystem.Path.Combine("Binary", "Objects", guid.ToString());
string destFilename = string.Concat(guid.ToString(), fileExtension);
string destPath = fileSystem.Path.Combine(path, destFilename);
fileSystem.Directory.CreateDirectory(fileSystem.Path.Combine(configuration.WorkingDirectory, path));
fileSystem.File.Move(request.SourcePath, fileSystem.Path.Combine(configuration.WorkingDirectory, destPath));
var entity = new ObjectEntity()
{
Id = guid,
CreatedDate = DateTime.UtcNow,
ModifiedDate = DateTime.UtcNow,
OriginalFilename = request.OriginalFilename,
SourcePath = destPath
};
context.ObjectRepository.Add(entity);
await context.SaveChangesAsync(cancellationToken);
context.CommitTransaction();
return(ObjectModel.Create(entity));
}
protected override void caneEffect(MyCharacterController user, ObjectEntity target)
{
Debug.logger.Log("Target", target.name);
if (Array.Exists(BasisParameter.EffectAnimationTargetTags, t => t == target.tag) || target.tag == TagList.Wall) {
GameController.FieldActionController.objectPullOn(target,user);
}
}
public void AddObjectAt(ObjectEntity obj, int row, int col)
{
MoveComponent moveCom = obj.GetComponent(typeof(MoveComponent)) as MoveComponent;
moveCom.Position = GetPositonAt(row, col);
objectManager.AddObject(obj);
}
/// <summary>
/// Has the reporting user already complained about this user?
/// </summary>
/// <param name="appHandle">uniquely identifies the app that the users are in</param>
/// <param name="reportedUserHandle">uniquely identifies the user who is being reported</param>
/// <param name="reportingUserHandle">uniquely identifies the user doing the reporting</param>
/// <returns>true if this user has previously complained about this user</returns>
public async Task <bool> HasReportingUserReportedUserBefore(string appHandle, string reportedUserHandle, string reportingUserHandle)
{
// check the inputs
if (string.IsNullOrWhiteSpace(appHandle))
{
throw new ArgumentNullException("appHandle");
}
else if (string.IsNullOrWhiteSpace(reportedUserHandle))
{
throw new ArgumentNullException("reportedUserHandle");
}
else if (string.IsNullOrWhiteSpace(reportingUserHandle))
{
throw new ArgumentNullException("reportingUserHandle");
}
// get the table interface
CTStore store = await this.tableStoreManager.GetStore(ContainerIdentifier.UserReports);
ObjectTable lookupUniquenessTable = this.tableStoreManager.GetTable(ContainerIdentifier.UserReports, TableIdentifier.UserReportsLookupUniquenessByReportingUser) as ObjectTable;
// check if the reporting user has previously reported this user
string uniquenessKey = UniquenessObjectKey(reportedUserHandle, reportingUserHandle);
ObjectEntity uniquenessObject = await store.QueryObjectAsync <ObjectEntity>(lookupUniquenessTable, appHandle, uniquenessKey);
if (uniquenessObject == null)
{
return(false);
}
return(true);
}
static void Main(string[] args)
{
ObjectEntity objectEntity = new ObjectEntity();
objectEntity.NullableIntField = 10;
objectEntity.StringField = "teststring";
objectEntity.ListField = new List <SubObjectEntity>();
objectEntity.ListField.Add(new SubObjectEntity {
IntField = 1, DoubleField = 1.1
});
Schema schema = Schema.Parse(SchemaClass.SCHEMA_OBJECT_ENTITY);
SpecificDatumWriter <ObjectEntity> w = new SpecificDatumWriter <ObjectEntity>(schema);
byte[] finalbytes = null;
using (MemoryStream memStream = new MemoryStream())
{
w.Write(objectEntity, new Avro.IO.BinaryEncoder(memStream));
memStream.Seek(0, SeekOrigin.Begin);
finalbytes = memStream.ToArray();
}
EventData eventToSend = new EventData(finalbytes);
EventHubClient eventHubClient = EventHubClient.CreateFromConnectionString(
"<eventhubconnection>",
"<eventhubname>"
);
eventHubClient.SendAsync(eventToSend).Wait();
}
protected override void caneEffect(MyCharacterController user, ObjectEntity target)
{
var c = target as MyCharacterController;
if (c != null) {
GameController.FieldActionController.objectRandomWarp(c, user.InRoom);
}
}
public static void Run(
[EventHubTrigger("%EventHubName%", Connection = "EventHubConnection", ConsumerGroup = "%ConsumerGroupName%")] EventData[] eventHubMessages,
Microsoft.Azure.WebJobs.ExecutionContext exCtx,
PartitionContext PartitionContext,
TraceWriter log)
{
try
{
log.Info($"Function1 | Run - functionId: {exCtx.InvocationId}");
Schema writerObjectSchema = Schema.Parse(SchemaClass.SCHEMA_OBJECT_ENTITY);
Avro.Specific.SpecificDatumReader <ObjectEntity> r = new Avro.Specific.SpecificDatumReader <ObjectEntity>(writerObjectSchema, writerObjectSchema);
for (int i = 0; i < eventHubMessages.Length; i++)
{
ObjectEntity objectEntityWithSchema = null;
using (MemoryStream memStream = new MemoryStream(eventHubMessages[i].GetBytes()))
{
memStream.Seek(0, SeekOrigin.Begin);
objectEntityWithSchema = r.Read(null, new Avro.IO.BinaryDecoder(memStream));
}
/// Here use the deserialized object for your logic
/// Put your code here
///
}
log.Info($"Function1 | Run - functionId: {exCtx.InvocationId}");
}
catch (Exception ex)
{
log.Error($"Function1 | Run - functionId: {exCtx.InvocationId}. Error StackTrace: {ex.StackTrace}");
throw;
}
}
protected override void caneEffect(MyCharacterController user, ObjectEntity target)
{
var c = target as MyCharacterController;
if (c != null) {
c.registerBuff(new MissedSwing(c,BasisParameter.EffectPoint));
}
}
public void AddObject(ObjectEntity obj)
{
if (!visibleObjects.Contains(obj))
{
visibleObjects.Add(obj);
}
}
protected override void caneEffect(MyCharacterController user, ObjectEntity target)
{
var c = target as MyCharacterController;
if (c != null) {
c.registerBuff(new Paralyze(c, BasisParameter.EffectPoint, StatusBuffBasis.CountDownType.TURN));
}
}
// return success
public bool MoveObject(ObjectEntity obj, Vector3Int newPosition)
{
if (newPosition == obj.position)
{
return(true);
}
Voxel newObjVoxel = VoxelAt(newPosition, true);
if (newObjVoxel.objectEntity != null)
{
return(false);
}
newObjVoxel.objectEntity = obj;
// not necessary to call VoxelModified
Voxel oldObjVoxel = VoxelAt(obj.position, false);
if (oldObjVoxel != null)
{
oldObjVoxel.objectEntity = null;
VoxelModified(oldObjVoxel);
}
else
{
Debug.Log("This object wasn't in the voxel array!");
}
obj.position = newPosition;
ObjectModified(obj);
return(true);
}
public WarpObject(ObjectEntity target, Vector2 warpdst)
: base(null)
{
Target = target;
WarpDestination = warpdst;
//JumpUpDist = Target.Position + dist;
}
public async Task <OknObject> CreateObject(CreateObjectCommand command, CancellationToken cancellationToken)
{
var entity = new ObjectEntity
{
ObjectId = Guid.NewGuid().ToString().ToLower().Replace("_", ""),
Name = command.Name,
Description = command.Description,
Longitude = command.Longitude,
Latitude = command.Latitude,
Type = command.Type,
EventsCount = 0,
Events = null,
Version = new VersionInfoEntity(1, new UserInfoEntity(command.UserId, command.UserName, command.Email)),
MainPhoto = command.MainPhoto != null
? ProcessFileInfo(command.MainPhoto)
: null
};
if (command.Photos != null)
{
entity.Photos = command.Photos.Select(x => ProcessFileInfo(x)).ToList();
}
await _context.Objects.InsertOneAsync(entity, cancellationToken : cancellationToken);
return(_mapper.Map <ObjectEntity, OknObject>(entity));
}
protected override void caneEffect(MyCharacterController user, ObjectEntity target)
{
var c = target as MyCharacterController;
if (c != null) {
c.Parameter.levelDown(BasisParameter.EffectPoint);
}
}
public void RemoveObject(ObjectEntity obj)
{
if (visibleObjects.Contains(obj))
{
visibleObjects.Remove(obj);
}
}
protected override void caneEffect(MyCharacterController user, ObjectEntity target)
{
if (isTargetObject(target)) {
var c = (target as MyCharacterController);
c.registerBuff(new SpeedDown(c, BasisParameter.EffectPoint));
}
}
protected override void caneEffect(MyCharacterController user, ObjectEntity target)
{
var c = target as MyCharacterController;
if (c != null) {
c.registerBuff(new Explosiveness(c));
}
//throw new NotImplementedException();
}
public ObjectListModel MapToListModel(ObjectEntity entity)
{
return(new ObjectListModel
{
Id = entity.Id,
Name = entity.Name
});
}
private void SpawnEntity(SpawnPoint.Entity entityDesc)
{
var entity = ObjectEntity.FromSpawnPoint(_kernel, entityDesc);
entity.LoadMesh(_graphics.GraphicsDevice);
_objectEntities.Add(entity);
}
public ExplosionObject(MyCharacterController owner,Vector2 center, FieldActionController.ExplisionLevel level,ObjectEntity[] targets)
: base(owner)
{
Targets = targets;
Center = center;
Level = level;
Damage = 0;
}
public BuffAnimationEntity createBuffAnimationEntity(ObjectEntity owner)
{
var ret = GameObject.Instantiate(bufforg);
ret.transform.parent = owner.transform;
ret.transform.localPosition = new Vector3(-0.25f, 0.25f, 1);
ret.transform.localScale = new Vector2(0.5f,0.5f);
return ret.GetComponent<BuffAnimationEntity>();
}
public static DestroyObjectEntityEventPayload Create(ObjectEntity objectEntity, Transform sender)
{
return(new DestroyObjectEntityEventPayload
{
ObjectEntity = objectEntity,
Sender = sender
});
}
public void AddActor(SpawnPoint.Entity entityDesc)
{
var entity = ObjectEntity.FromSpawnPoint(_kernel, entityDesc);
entity.LoadMesh(_graphicsDevice);
_actors.Add(entity);
}
public ExertionItemEffect(MyCharacterController user,ItemBasis item ,bool throwhit,ObjectEntity[] targets,params ExeritionOption[] options)
: base(user)
{
Targets = new List<ObjectEntity>(targets);
Item = item;
ThrowHit = throwhit;
Options = options==null?new ExeritionOption[] { }:options;
}
private IEnumerator SelectNewObjectCoroutine(ObjectEntity obj)
{
yield return(null);
ClearStoredSelection();
TouchDown(obj.marker);
TouchUp();
}
public void AddActor(int actorId, int objectId)
{
var entity = new ObjectEntity(_kernel, _kernel.GetRealObjectId(objectId));
entity.LoadMesh(_graphicsDevice);
_actors.Add(entity);
_actorIds[actorId] = entity;
}
private JSONObject WriteObjectEntity(ObjectEntity objectEntity, bool includeName)
{
JSONObject entityObject = WriteEntity(objectEntity, includeName);
entityObject["at"] = WriteIntVector3(objectEntity.position);
entityObject["rotate"] = objectEntity.rotation;
return(entityObject);
}
private static MessagePackObjectDictionary WriteObjectEntity(ObjectEntity objectEntity, bool includeName)
{
var entityDict = WriteEntity(objectEntity, includeName);
entityDict[FileKeys.OBJECT_POSITION] = WriteIntVector3(objectEntity.position);
entityDict[FileKeys.OBJECT_ROTATION] = objectEntity.rotation;
return(entityDict);
}
public ObjectDetailModel MapToDetail(ObjectEntity entity)
{
return(new ObjectDetailModel
{
Id = entity.Id,
Name = entity.Name,
Description = entity.Description
});
}
public override void HandleObjectDestroyed(ObjectEntity objectEntity)
{
base.HandleObjectDestroyed(objectEntity);
var objectDestroyRequest = new ObjectDestroyRequest()
{
ObjectId = objectEntity.Id,
};
Send(objectDestroyRequest).Wait();
}
private static MessagePackObjectDictionary WriteObjectEntity(ObjectEntity objectEntity,
Dictionary <Material, int> materials, Dictionary <Material, int> overlays)
{
var entityDict = WriteEntity(objectEntity, true);
entityDict[FileKeys.OBJECT_POSITION] = WriteVector3Int(objectEntity.position);
entityDict[FileKeys.OBJECT_ROTATION] = objectEntity.rotation;
entityDict[FileKeys.OBJECT_PAINT] = WriteFace(objectEntity.paint, 0, materials, overlays);
return(entityDict);
}
protected override void caneEffect(MyCharacterController user, ObjectEntity target)
{
if (isTargetObject(target)) {
var c = target as MyCharacterController;
float userHP = user.Parameter.CurrentHP;
float targetHP = c.Parameter.CurrentHP;
user.Parameter.CurrentHP = Mathf.Min(targetHP, user.Parameter.MaxHP);
c.Parameter.CurrentHP = Mathf.Min(userHP, c.Parameter.MaxHP);
}
}
protected override void caneEffect(MyCharacterController user, ObjectEntity target)
{
MyCharacterController c = target as MyCharacterController;
if (c == null) return;
var token = new ElementalDamage(user, c, BasisParameter.EffectPoint, CharacterParameterBasis.Elemental.FIRE);
token.ShowLogAction = d => GameController.PlayingLogger.damagedObject(c.Parameter.Name, (int)d, c.isDead);
c.damaged(token);
//character.damagedFromCharacterAttack(BasisParameter.EffectPoint,user,false);
//user.killedTarget(character);
//GameController.PlayingLogger.damagedObject(character.Parameter.Name,BasisParameter.EffectPoint,character.isDead);
}
public void AddObject(ObjectEntity obj)
{
objects.Add(obj);
Voxel objVoxel = VoxelAt(obj.position, true);
if (objVoxel.objectEntity != null)
{
Debug.Log("Object already at position!!");
}
objVoxel.objectEntity = obj;
// not necessary to call VoxelModified
}
private void ReadObjectEntity(MessagePackObjectDictionary entityDict, ObjectEntity objectEntity)
{
ReadEntity(entityDict, objectEntity);
if (entityDict.ContainsKey(FileKeys.OBJECT_POSITION))
{
objectEntity.position = ReadVector3Int(entityDict[FileKeys.OBJECT_POSITION]);
}
if (entityDict.ContainsKey(FileKeys.OBJECT_ROTATION))
{
objectEntity.rotation = entityDict[FileKeys.OBJECT_ROTATION].AsSingle();
}
}
public async Task <OknObject> GetObject(ObjectQuery query, CancellationToken cancellationToken)
{
var filter = Builders <ObjectEntity> .Filter.Where(x => x.ObjectId == query.ObjectId);
ObjectEntity entity = null;
var excludeFields = Builders <ObjectEntity> .Projection.Exclude(d => d.Events);
if (query.Version.HasValue)
{
var versionFilter = Builders <ObjectEntity> .Filter
.Where(x => x.Version.VersionId == query.Version);
var emptyVersionFilter = Builders <ObjectEntity> .Filter
.Where(x => x.Version == null);
filter = Builders <ObjectEntity> .Filter
.And(filter, query.Version == 0?emptyVersionFilter : versionFilter);
entity = await _context.ObjectVersions
.Find(filter)
.Project <ObjectEntity>(excludeFields)
.SortByDescending(x => x.Version.VersionId)
.FirstOrDefaultAsync(cancellationToken);
}
//if not found in versions table - try to get last version
if (entity == null)
{
entity = await _context.Objects
.Find(filter)
.Project <ObjectEntity>(excludeFields)
.FirstOrDefaultAsync(cancellationToken);
//check if requested version is last version
if (entity != null && query.Version.HasValue && query.Version.Value != entity.Version?.VersionId)
{
//current version has different version, so requested version not found
return(null);
}
}
if (entity != null)
{
var model = _mapper.Map <ObjectEntity, OknObject>(entity);
model.Events = model.Events.OrderByDescending(x => x.OccuredAt).ToList();
return(model);
}
return(null);
}
private void ReadObjectEntity(JSONObject entityObject, ObjectEntity objectEntity)
{
ReadEntity(entityObject, objectEntity);
if (entityObject["at"] != null)
{
objectEntity.position = ReadVector3Int(entityObject["at"].AsArray);
}
if (entityObject["rotate"] != null)
{
objectEntity.rotation = entityObject["rotate"].AsFloat;
}
}
public void Remove(Guid id)
{
using (var context = new MyPhotoDbContext())
{
var entity = new ObjectEntity()
{
Id = id
};
context.Pictures.Include(r => r.PictureObjectCollection).Where(x => x.PictureObjectCollection.Any(y => y.PictureObject.Id == id)).ToList();
context.Objects.Attach(entity);
context.Objects.Remove(entity);
context.SaveChanges();
}
}
public override void HandleYell(ObjectEntity objectEntity, string message, ChatLanguage language)
{
base.HandleYell(objectEntity, message, language);
var chatResponse = new ChatMessageResponse()
{
Language = language,
Message = message,
MessageType = ChatMessageType.Yell,
SenderId = objectEntity.Id,
Tag = ChatTag.None,
TargetId = State.Id,
};
Send(chatResponse).Wait();
}
private void ReadObjectEntity(MessagePackObjectDictionary entityDict, ObjectEntity objectEntity,
List <Material> materials, List <Material> overlays)
{
ReadEntity(entityDict, objectEntity);
if (entityDict.ContainsKey(FileKeys.OBJECT_POSITION))
{
objectEntity.position = ReadVector3Int(entityDict[FileKeys.OBJECT_POSITION]);
}
if (entityDict.ContainsKey(FileKeys.OBJECT_ROTATION))
{
objectEntity.rotation = entityDict[FileKeys.OBJECT_ROTATION].AsSingle();
}
if (entityDict.ContainsKey(FileKeys.OBJECT_PAINT))
{
objectEntity.paint = ReadFace(entityDict[FileKeys.OBJECT_PAINT], out int _,
materials, overlays);
}
}
/// <summary>
/// Creates a model based on the given domain entity.
/// </summary>
/// <param name="entity">The domain entity.</param>
/// <returns>The domain entity as a model.</returns>
public static ObjectModel Create(ObjectEntity entity)
{
if (entity == null)
{
return(null);
}
return(new ObjectModel
{
Id = entity.Id.ToString(),
CreatedDate = entity.CreatedDate,
ModifiedDate = entity.ModifiedDate,
DataType = Enum.TryParse(entity.DataType.ToString(), out DataType dataType) ? dataType : DataType.Unknown,
FileFormat = Enum.TryParse(entity.FileFormat.ToString(), out FileFormat fileFormat) ? fileFormat : FileFormat.Unknown,
OriginalFilename = entity.OriginalFilename,
SourcePath = entity.SourcePath,
UncompressedPath = entity.UncompressedPath
});
public void DeleteObject(ObjectEntity obj)
{
objects.Remove(obj);
if (obj.marker != null)
{
Destroy(obj.marker.gameObject);
obj.marker = null;
}
Voxel objVoxel = VoxelAt(obj.position, false);
if (objVoxel != null)
{
objVoxel.objectEntity = null;
VoxelModified(objVoxel);
}
else
{
Debug.Log("This object wasn't in the voxel array!");
}
}
// return false if object could not be placed
public bool PlaceObject(ObjectEntity obj)
{
Vector3 createPosition = selectionBounds.center;
int faceNormal = GetSelectedFaceNormal();
Vector3 createDirection = Voxel.DirectionForFaceI(faceNormal);
if (faceNormal != -1)
{
createPosition += createDirection / 2;
}
else
{
faceNormal = 3;
createDirection = Vector3.up;
}
createPosition -= new Vector3(0.5f, 0.5f, 0.5f);
// don't create the object at the same location of an existing object
// keep moving in the direction of the face normal until an empty space is found
while (true)
{
Voxel voxel = VoxelAt(createPosition, false);
if (voxel != null && voxel.substance == null && !voxel.faces[Voxel.OppositeFaceI(faceNormal)].IsEmpty())
{
return(false); // blocked by wall. no room to create object
}
if (voxel == null || voxel.objectEntity == null)
{
break;
}
createPosition += createDirection;
}
obj.position = VoxelArray.Vector3ToInt(createPosition);
obj.InitObjectMarker(this);
AddObject(obj);
unsavedChanges = true;
// select the object. Wait one frame so the position is correct
StartCoroutine(SelectNewObjectCoroutine(obj));
return(true);
}
public void Kiss(string cmd, string[] args)
{
if (cmd != "KISS")
{
return;
}
if (args.Length != 1)
{
console.InvokeOnErrorCommand(cmd);
return;
}
if (args[0] == "PRINCESS")
{
GameObject princess = GameObject.FindGameObjectWithTag("Princess");
if (princess == null)
{
console.InvokeOnErrorCommand(cmd);
return;
}
ObjectEntity entity = princess.GetComponent <ObjectEntity>();
if (!visibleObjects.Contains(entity))
{
console.InvokeOnErrorCommand(cmd);
return;
}
EndGame end = princess.GetComponent <EndGame>();
if (end.isVisible)
{
end.Finish();
}
}
else
{
ErrorCommand("");
ErrorCommand("");
ErrorCommand("");
ErrorCommand("");
console.InvokeOnErrorCommand(cmd);
}
}
protected override void caneEffect(MyCharacterController user, ObjectEntity target)
{
var c = target as MyCharacterController;
if (c != null) {
var spos = MyCharacterController.NULLPOS;
if (GameController.DungeonInformation.StairsPosition == null)
{
spos = GameController.DungeonInformation.CurrentFloor.Rooms[0].CenterToInt;
}
else {
spos = GameController.DungeonInformation.StairsPosition;
}
var objs = GameController.DungeonInformation.findAllObjectWithArea(spos,new Vector2(9,9),TagList.Road,TagList.Character);
//objs.RemoveAll(obj => obj is MyCharacterController);
var poss = objs.ConvertAll(obj => obj.Position);
poss.RemoveAll(p => !c.canMoveNextPosition(p));
poss.Sort((a, b) => (int)(Vector2.Distance(a, spos) - Vector2.Distance(b, spos)));
c.registerBuff(new Sleep(c,BasisParameter.EffectPoint));
GameController.ActResultController.add(new WarpObject(c, poss[0]));
}
}
public virtual EffectAnimationEntity[] getEffectAnimation(MyCharacterController owner, ObjectEntity target)
{
//GameController.PlayingLogger.addLogFormat("{0}:{1}",EffectAnimationName,target);
var effect = GameController.EffectAnimationController.singleshotEffect(EffectAnimationName, target.Position, 1, 1, false);
if (effect != null) { return new EffectAnimationEntity[] { effect }; }
else { return new EffectAnimationEntity[] { }; }
}
protected override void caneEffect(MyCharacterController user, ObjectEntity target)
{
if (isTargetObject(target)) {
GameController.FieldActionController.objectSwapPosition(user, target);
}
}
protected override void caneEffect(MyCharacterController user, ObjectEntity target)
{
}
public void exertion(MyCharacterController user,ObjectEntity target)
{
GameController.ActResultController.add(new ExertionAbility(user, target, this));
}
private void Dummy(ObjectEntity entity)
{
}
public void whenDamaged(PlayerController player, ObjectEntity attacker, int damage)
{
}
public void despawnObject(ObjectEntity entiy)
{
DespawnObjectEntity(entiy);
//AsyncCallback callback = (a) => { if (a.IsCompleted) entiy.Object = null; };
}
public void spawnObject(ObjectEntity entiy)
{
//Debug.Log(entiy.name);
SpawnObjectEntity(entiy);
}
public ExplosionObject(MyCharacterController owner, Vector2 center, int damage, ObjectEntity[] targets)
: this(owner,center,FieldActionController.ExplisionLevel.ONE,targets)
{
Damage = damage;
}
protected override void caneEffect(MyCharacterController user, ObjectEntity target)
{
if (Array.Exists(BasisParameter.EffectAnimationTargetTags,t => t == target.tag)) {
GameController.FieldActionController.objectPullOn(user, target);
}
}
public ExertionAbility(MyCharacterController owner, ObjectEntity target, AbilityBasis ability)
: base(owner)
{
Target = target;
Ability = ability;
}
public void preoperation(PlayerController player)
{
var find = Physics2D.RaycastAll(player.FrontPos, MyCharacterController.getDirectionDelta(player.CurrentDirection), distance, mask);
if (find.Length != 0) {
var targets = Array.ConvertAll(find, t => t.collider.GetComponent<ObjectEntity>());
Array.Sort(targets,(a,b)=> {
var ret = (int)(Vector2.Distance(a.Position, player.Position) - Vector2.Distance(b.Position, player.Position));
if (ret == 0) {
int n1 = (a is TileEntity) ? -1 : 0;
int n2 = (b is TileEntity) ? -1 : 0;
ret = n1 - n2;
}
return ret;
} );
Target = targets[0];
}
}
public ExplosionObject(Vector2 center, FieldActionController.ExplisionLevel level, ObjectEntity[] targets)
: this(null, center, level, targets)
{
}
