private string GetReleaseAbbr(ReleaseState state)
{
switch (state)
{
case ReleaseState.PreAlpha:
return("pa");
case ReleaseState.Alpha:
return("a");
case ReleaseState.PreBeta:
return("pb");
case ReleaseState.Beta:
return("b");
case ReleaseState.ReleaseCandidate:
return("rc");
case ReleaseState.Release:
return("r");
default:
throw new ArgumentException("Invalid release state.");
}
}
internal ElasticsearchVersion(string version, string zip, ReleaseState state, string localFolder) : base(version)
{
this.Version = version;
this.ReleaseState = state;
this.Zip = zip;
this.ExtractFolderName = localFolder;
this.DownloadLocations = new ElasticsearchDownloadLocations(this);
}
internal static void AddOrUpdate(ReleaseState release)
{
AddOrUpdate(Releases, release);
if (release.Subscription != null && release.IsPublished)
{
AddOrUpdate(PublishedReleases, release);
}
}
public static BitmapImage GetCoverOverlay(ReleaseState state)
{
if (state == ReleaseState.Release)
{
return(null);
}
return(new BitmapImage(new Uri($"pack://application:,,,/{typeof(ResourcesHelper).Assembly.GetName().Name};component/Resources/{state.ToString()}.png")));
}
private bool OnSubscriptionCreate(SubscriptionCreateCommand command)
{
if (!IsSubscriptionValid(command) || _state.Subscription != null)
{
return(false);
}
PersistAsync(command, cmd =>
{
_state = _state.AddSubscription(Guid.NewGuid().ToString(), command);
TellStateUpdated();
});
return(true);
}
private bool OnSubscriptionReplace(SubscriptionReplaceCommand command)
{
if (!IsSubscriptionValid(command))
{
return(false);
}
PersistAsync(command, cmd =>
{
_state = _state.ReplaceSubscription(command);
TellStateUpdated();
});
return(true);
}
private bool OnMetadataUpdated(MetadataUpdateCommand command)
{
if (!CommandValidator.Validate(command).Success ||
command.ReleaseId != PersistenceId ||
!_state.TrackList.ContainsKey(command.TrackId) ||
command.Timestamp <= _state.TrackList[command.TrackId].Timestamp)
{
return(false);
}
Persist(command, cmd =>
{
_state = _state.UpdateMetadata(cmd);
TellStateUpdated();
});
return(true);
}
public void Store(ReleaseState state)
{
var entity = new Entity
{
Key = ReleaseKeyFactory.CreateKey(state.ReleaseId),
[nameof(ReleaseState.Artist)] = state.Artist,
[nameof(ReleaseState.Title)] = state.Title,
[nameof(ReleaseState.Genre)] = state.Genre,
[nameof(ReleaseState.OwnerId)] = state.OwnerId.ToString(),
[nameof(ReleaseState.Cover)] = state.Cover,
[nameof(ReleaseState.TrackList)] = state.TrackList.Select(t => ToEntity(t.Value)).ToArray(),
[nameof(ReleaseState.Subscription)] = ToEntity(state.Subscription),
[nameof(ReleaseState.Timestamp)] = state.Timestamp,
};
Database.Upsert(entity);
}
public void SwitchState(HandGesture inputType)
{
BaseInputState state = null;
switch (inputType)
{
case HandGesture.Touching:
state = new TouchingState(m_InputTouch);
break;
case HandGesture.Click:
state = new ClickState(m_InputTouch);
break;
case HandGesture.Holding:
state = new HoldingState(m_InputTouch);
break;
case HandGesture.Drag:
state = new DragState(m_InputTouch);
break;
case HandGesture.Slip:
state = new SlipState(m_InputTouch);
break;
case HandGesture.Realease:
state = new ReleaseState(m_InputTouch);
break;
default:
state = new NoneInput(m_InputTouch);
break;
}
if (state != null)
{
Switch(state);
}
else
{
Debug.Log("InputStateFSM.SwitchState " + inputType + "is None");
}
}
private void ReleaseQuery(ThreadQueue.TaskControl control, object state)
{
try
{
if (db != null)
{
ReleaseState rlState = state as ReleaseState;
rlState.Query.Release();
}
else
{
throw new Exception("Database not ready!");
}
}
catch (Exception ex)
{
Debug.LogError("SQLiteAsync : Exception : " + ex.Message);
}
}
public ReleaseActor(ReleaseState state, ImmutableHashSet <string> exitstingTrackIds, ActorPath readStorageUpdateActor)
{
_readStorageUpdateActor = readStorageUpdateActor;
Command <ReleaseUpdateCommand>(msg => HandleUpdateMessage(msg));
Command <TrackListUpdated>(msg => OnTrackListUpdated(msg));
Command <MetadataCreateCommand>(m => HandleMetadataAdded(m));
Command <MetadataUpdateCommand>(m => OnMetadataUpdated(m));
Command <SubscriptionCreateCommand>(c => OnSubscriptionCreate(c));
Command <SubscriptionReplaceCommand>(c => OnSubscriptionReplace(c));
Recover <ReleaseUpdateCommand>(msg => HandleUpdateMessage(msg));
Recover <TrackListUpdated>(msg => OnTrackListUpdated(msg));
Recover <MetadataCreateCommand>(m => HandleMetadataAdded(m));
Recover <MetadataUpdateCommand>(m => OnMetadataUpdated(m));
Recover <SubscriptionCreateCommand>(c => OnSubscriptionCreate(c));
Recover <SubscriptionReplaceCommand>(c => OnSubscriptionReplace(c));
_state = state;
TrackIds = exitstingTrackIds;
TellStateUpdated();
}
// Update is called once per frame
void Update ()
{
switch( m_State )
{
case ReleaseState.Ready :
m_State = ReleaseState.Fire ;
break ;
case ReleaseState.Fire :
InstantiateMissle() ;
m_State = ReleaseState.Reload ;
m_FireTime = Time.timeSinceLevelLoad ;
break ;
case ReleaseState.Reload :
if( Time.timeSinceLevelLoad > m_FireTime + m_ReloadSec )
{
m_State = ReleaseState.Ready ;
}
break ;
}
}
public BaseItemDefinition(
string metadataId, string name, ItemClass itemClass, IEnumerable <string> rawTags, Tags tags,
IReadOnlyList <Property> properties, IReadOnlyList <UntranslatedStat> buffStats, Requirements requirements,
IReadOnlyList <CraftableStat> implicitModifiers, int inventoryHeight, int inventoryWidth, int dropLevel,
ReleaseState releaseState, string visualIdentity)
{
MetadataId = metadataId;
Name = name;
ItemClass = itemClass;
RawTags = rawTags;
Tags = tags;
Properties = properties;
BuffStats = buffStats;
Requirements = requirements;
ImplicitModifiers = implicitModifiers;
InventoryHeight = inventoryHeight;
InventoryWidth = inventoryWidth;
DropLevel = dropLevel;
ReleaseState = releaseState;
VisualIdentity = visualIdentity;
}
// Update is called once per frame
void Update()
{
switch (m_State)
{
case ReleaseState.Ready:
m_State = ReleaseState.Fire;
break;
case ReleaseState.Fire:
InstantiateMissle();
m_State = ReleaseState.Reload;
m_FireTime = Time.timeSinceLevelLoad;
break;
case ReleaseState.Reload:
if (Time.timeSinceLevelLoad > m_FireTime + m_ReloadSec)
{
m_State = ReleaseState.Ready;
}
break;
}
}
private bool HandleMetadataAdded(MetadataCreateCommand command)
{
if (!IsMetadataAddValid(command))
{
return(false);
}
var evt = new MetadataCreated
{
TrackId = command.TrackId,
Album = command.Album,
Artist = command.Artist,
Genre = command.Genre,
Timestamp = command.Timestamp,
Title = command.Title
};
Persist(evt, e =>
{
_state = _state.AddMetadata(command);
TellStateUpdated();
});
return(true);
}
public SkillBaseItemDefinition(
string displayName, string metadataId, ReleaseState releaseState, IEnumerable <string> gemTags)
=> (DisplayName, MetadataId, ReleaseState, GemTags) = (displayName, metadataId, releaseState, gemTags);
public void OnReleaseStateChange(ReleaseState state)
{
InMemoryAppState.AddOrUpdate(state);
_releaseProvider.Store(state);
}
private static void AddOrUpdate(ConcurrentDictionary <string, ReleaseState> storage, ReleaseState release)
{
if (storage.ContainsKey(release.ReleaseId))
{
storage[release.ReleaseId] = release;
}
else
{
storage.TryAdd(release.ReleaseId, release);
}
}
private void UpdateState(ReleaseUpdateCommand command)
{
_state = _state.Update(command);
}
private void ReleaseQueryComplete(object state)
{
ReleaseState rlState = state as ReleaseState;
rlState.Callback(rlState.State);
}
public SkillBaseItemDefinition(
string displayName, string metadataId, ReleaseState releaseState, IReadOnlyCollection <string> gemTags)
=> (DisplayName, MetadataId, ReleaseState, GemTags) = (displayName, metadataId, releaseState, gemTags);
private IActorRef PlaceChildActor(ReleaseState state)
{
return(Context.ActorOf(Props.Create(() => new ReleaseActor(state, ExistingTrackIds, _readStorageUpdateActor)), state.ReleaseId));
}
internal void setState(ReleaseState state)
{
this.m_releaseStates = state;
}
