public static async Task <string> ActiveRideStarted(
RideInfo rideInfo,
UserRideOffer driver,
IEnumerable <UserRideRequest> riders)
{
ActiveRideStatus status =
new ActiveRideStatus
{
Id = IdGenerator.GenerateNewId(rideInfo),
Version = 0,
RideInfo = rideInfo,
RideState = ActiveRideStatus.State.InProgress,
RidersState = new ConcurrentDictionary <string, ActiveRideStatus.RiderState>(
riders.Select(
(r) => new KeyValuePair <string, ActiveRideStatus.RiderState>(
r.User.UserInfo.UserId,
ActiveRideStatus.RiderState.Waiting))),
RidersGameElements = new ConcurrentDictionary <string, RequestGameElements>(
riders
.Where((r) => r.RideRequest.GameElements != null)
.Select((r) => new KeyValuePair <string, RequestGameElements>(
r.User.UserInfo.UserId,
r.RideRequest.GameElements))),
DriverGameElements = driver.RideOffer.GameElements
};
Task postTask = Program.DataStore.PostActiveRideStatus(status);
activeRides.TryAdd(status.Id, status);
await postTask;
RideStarted?.Invoke(status);
return(status.Id);
}
public async Task PostActiveRideStatus(ActiveRideStatus status)
{
if (DataStore == null)
{
return;
}
string data = JsonConvert.SerializeObject(status);
await DataStore.PostStringResource(ActiveRideStatusName(status.Id), data);
}
async Task <Ridesharing.StateBase> TryComputeRideOfferState(string userId, RideRelatedRequestStatus offerStatus)
{
string requestId = offerStatus.Id;
string rideId = offerStatus.PendingRideId;
if (string.IsNullOrEmpty(rideId))
{
var requestNotifications = new PendingRideRelatedRequest(userId, requestId);
// FIXME Retrieve old RideOffer corresponding to requestId
return(new OfferPendingState(this, requestNotifications, null));
}
PendingRideStatus status = await App.Current.DataStore.GetPendingRideStatus(rideId);
if (status != null)
{
switch (status.State)
{
case PendingRideStatus.PendingRideState.Confirmed:
if (status.ActiveRideId == null)
{
break;
}
ActiveRideStatus activeRide = await App.Current.DataStore.GetActiveRideStatus(status.ActiveRideId);
if (activeRide == null)
{
break;
}
if (activeRide.RideState == ActiveRideStatus.State.InProgress)
{
return(new RideInProgressState(this, activeRide));
}
break;
case PendingRideStatus.PendingRideState.WaitingOnDriver:
return(new OfferMatchedState(this, new MatchedRideRelatedRequest(userId, requestId, rideId)));
case PendingRideStatus.PendingRideState.WaitingOnRiders:
return(new WaitingForConfirmedState(this, new MatchedRideRelatedRequest(userId, requestId, rideId)));
case PendingRideStatus.PendingRideState.Canceled:
break;
}
}
return(null);
}
/// <summary>
/// Figures out what the RideState should be based only on the riders' states
/// </summary>
/// <param name="status"></param>
/// <returns></returns>
static ActiveRideStatus.State RiderBasedRideState(ActiveRideStatus status)
{
if (status.RidersState.Values.Any((s) => s == ActiveRideStatus.RiderState.InRide || s == ActiveRideStatus.RiderState.Waiting))
{
return(ActiveRideStatus.State.InProgress);
}
if (status.RidersState.Values.Any((s) => s == ActiveRideStatus.RiderState.DroppedOff))
{
return(ActiveRideStatus.State.Finished);
}
return(ActiveRideStatus.State.Canceled);
}
async Task <ActiveRideStatus> GetRideInProgress(string userId)
{
IEnumerable <string> activeRideIds = await DataService.Instance.GetActiveRideIds(userId);
foreach (string activeRideId in activeRideIds)
{
ActiveRideStatus status = await App.Current.DataStore.GetActiveRideStatus(activeRideId);
if (status.RideState == ActiveRideStatus.State.InProgress)
{
return(status);
}
}
return(null);
}
async Task <Ridesharing.StateBase> GetCurrentState()
{
string userId = App.Current.UserInfo.UserId;
// Check if the user is currently in a ride.
ActiveRideStatus activeRideStatus = await GetRideInProgress(userId);
if (activeRideStatus != null)
{
return(new RideInProgressState(this, activeRideStatus));
}
// Check if user has a ride request.
RideRelatedRequestStatus requestStatus = await GetUnexpiredRequest(true, userId);
if (requestStatus != null)
{
var result = await TryComputeRideRequestState(userId, requestStatus);
if (result != null)
{
return(result);
}
}
// Check if user has a ride offer.
RideRelatedRequestStatus offerStatus = await GetUnexpiredRequest(false, userId);
if (offerStatus != null)
{
var result = await TryComputeRideOfferState(userId, offerStatus);
if (result != null)
{
return(result);
}
}
return(new NoneState(this));
}
static void OnRideEnded(ActiveRideStatus status)
{
OnRideEndedAsync(status).FireAndForgetAsync(Program.ErrorHandler);
}
static void OnUserFinishedRide(ActiveRideStatus status, string userId, bool isDriver)
{
OnUserFinishedRideAsync(status, userId, isDriver).FireAndForgetAsync(Program.ErrorHandler);
}
static void OnUserInRide(ActiveRideStatus status, string userId)
{
OnUserInRideAsync(status, userId).FireAndForgetAsync(Program.ErrorHandler);
}
static void OnUserCanceledRideInProgress(ActiveRideStatus status, string userId, bool isDriver)
{
OnUserCanceledRideInProgressAsync(status, userId, isDriver).FireAndForgetAsync(Program.ErrorHandler);
}
/// <summary>
/// When the whole ride ends
/// </summary>
/// <param name="rideId"></param>
static async Task OnRideEndedAsync(ActiveRideStatus status)
{
//Reward the driver:
{
string driverId = status.RideInfo.DriverId;
//Handle any equipped item
GameItem item = await ValidateAndTakeEquippedItem(driverId, status.DriverGameElements);
GameMultipliers multipliers = new GameMultipliers(item);
await AddNewEffect(driverId,
new CompoundEffect(
new GameInfoEffectBase[]
{
new LevelEffect((int)(1000 * multipliers.Level), "", "", ""),
new KingdomEffect((int)(500 * multipliers.Kingdom), "", "", ""),
new ItemEffect(
new GameItem(
"Sword",
GameItem.Effect.Level,
2,
10,
1,
flavorText: "It's sharp!"), "", "", "")
},
"Gave a ride",
"Gave a chocolate ride",
IdGenerator.GenerateNewId(status)
), true
);
}
//Reward the passengers
foreach (var kvp in status.RidersState)
{
//Only riders who finished the ride
//TODO this assuems that all riders either canceled, or got dropped off
if (kvp.Value == ActiveRideStatus.RiderState.Canceled)
{
continue;
}
GameItem item = null;
if (status.RidersGameElements.TryGetValue(kvp.Key, out RequestGameElements gameElements))
{
item = await ValidateAndTakeEquippedItem(kvp.Key, gameElements);
}
GameMultipliers multipliers = new GameMultipliers(item);
await AddNewEffect(kvp.Key,
new CompoundEffect(
new GameInfoEffectBase[]
{
new LevelEffect((int)(200 * multipliers.Level), "", "", ""),
new ItemEffect(
new GameItem(
"Ticket stub",
GameItem.Effect.None,
0,
startCount: 1,
flavorText: "What a nice ride it was"), "", "", "")
},
"Took a ride",
"Took a strawberry ride",
IdGenerator.GenerateNewId(status)
), true
);
}
}
#pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously
/// <summary>
/// When a user finishes a ride (The whole ride might not be finished yet, but this user is done with it)
/// </summary>
/// <param name="rideId"></param>
/// <param name="userId"></param>
/// <param name="isDriver"></param>
static async Task OnUserFinishedRideAsync(ActiveRideStatus status, string userId, bool isDriver)
#pragma warning restore CS1998 // Async method lacks 'await' operators and will run synchronously
{
}
#pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously
/// <summary>
/// The ride has started
/// </summary>
/// <param name="rideId"></param>
static async Task OnRideStartedAsync(ActiveRideStatus status)
#pragma warning restore CS1998 // Async method lacks 'await' operators and will run synchronously
{
}
public RideInProgressState(Ridesharing.StateBase previous, ActiveRideStatus rideStatus)
: base(previous)
{
MostRecentRideStatus = rideStatus;
}
