// Use this for initialization
void Start()
{
prevClipPlayTime = 0f;
waitingClips = new List <AudioEvent>();
// normalize
foreach (AudioClipManager acm in audioClipManager)
{
acm.NormalizeClipPlayChance();
}
// put into more useful format
announcerClips = new Dictionary <AnnouncementType, AudioClipManager>();
for (int i = 0; i < audioClipManager.Length; i++)
{
AnnouncementType t = audioClipManager[i].announcementType;
//PlayerReactionType pt = audioClipManager[i].playerType;
if (!announcerClips.ContainsKey(t))
{
announcerClips.Add(t, audioClipManager[i]);
}
}
matchClips = new Dictionary <MatchEffect, MatchProgressionEffects>();
for (int i = 0; i < matchClipManager.Length; i++)
{
MatchEffect t = matchClipManager[i].type;
//PlayerReactionType pt = audioClipManager[i].playerType;
if (!matchClips.ContainsKey(t))
{
matchClips.Add(t, matchClipManager[i]);
}
}
}
void SetupAnnouncement()
{
AnnouncementType announcementType = AnnouncementType.None;
switch (Game.State)
{
case GameState.PreMinigame:
announcementType = AnnouncementType.PregameStart;
break;
case GameState.InMinigame:
announcementType = AnnouncementType.InGameStart;
break;
case GameState.PostMinigame:
announcementType = AnnouncementType.PostgameStart;
break;
default:
return;
}
if (announcementType != AnnouncementType.None)
{
Play(announcementType);
}
}
public Announcement(string id, string title, DateTime creationDate, AnnouncementType type)
{
Id = id;
Title = title;
Type = type;
CreationDate = creationDate;
}
public ActionResult Index(int announcementId, AnnouncementType announcementType, int?attributeId)
{
ViewBag.AnnouncementId = announcementId;
ViewBag.AnnouncementType = announcementType;
ViewBag.AttributeId = attributeId;
return(View("Index"));
}
public async Task <ActionResult> Upload(int announcementId, AnnouncementType announcementType, int?attributeId)
{
try
{
byte[] bin;
string name;
if (!GetFileFromRequest(out bin, out name))
{
throw new Exception("File required");
}
using (var fileStream = new MemoryStream())
{
fileStream.Write(bin, 0, bin.Length);
fileStream.Seek(0, SeekOrigin.Begin);
if (attributeId.HasValue)
{
await Connector.Announcement.UploadAttributeAttachment(announcementId, announcementType, attributeId.Value, name, fileStream);
}
else
{
await Connector.Announcement.UploadAnnouncementAttachment(announcementId, announcementType, name, fileStream);
}
}
}
catch (Exception e)
{
if (Request.IsAjaxRequest())
{
return(Json(new { success = false, message = e.ToString() }, "text/html"));
}
throw;
}
return(Json(new { success = true }, "text/html", JsonRequestBehavior.AllowGet));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Text,CreatedBy,CreatedAt,LastUpdatedBy,LastUpdatedAt,IsDeleted,DeletedBy,DeletedAt")] AnnouncementType announcementType)
{
if (id != announcementType.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(announcementType);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!AnnouncementTypeExists(announcementType.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(announcementType));
}
public AudioEvent(AnnouncementType aType, AudioPriority aPrior, float t, float et)
{
type = aType;
priority = aPrior;
timeOccurred = t;
timeToExpire = et;
}
public void Play(AnnouncementType type)
{
if (spriteRenderer == null)
{
return;
}
switch (type)
{
case AnnouncementType.PregameStart:
spriteRenderer.sprite = PregameStartImage;
break;
case AnnouncementType.InGameStart:
spriteRenderer.sprite = InGameStartImage;
break;
case AnnouncementType.PostgameStart:
spriteRenderer.sprite = PostgameStartImage;
break;
default:
return;
}
transform.localScale = new Vector3(3f, 3f, 3f);
transform.DOScale(Vector3.one, 0.25f);
spriteRenderer.color = Color.white;
spriteRenderer.DOColor(Color.clear, 1.0f).SetDelay(1f);
}
//[NoCache]
public ActionResult Apartments(ApartmentFilterCriteria filter, AnnouncementType type = AnnouncementType.Buy, AnnouncementOrder order = AnnouncementOrder.Address, NavigationViewType viewtype = NavigationViewType.List, int page = 1, bool considerEmpty = true)
{
IEnumerable <ApartmentAnnouncement> apartments = _announcementRepository.GetListOfApartments().Where(an => an.Type == type && an.Address.HasValue);
switch (order)
{
case AnnouncementOrder.Address: apartments = apartments.OrderBy(a => a.Address.ToString()); break;
case AnnouncementOrder.AddressDescending: apartments = apartments.OrderByDescending(a => a.Address.ToString()); break;
case AnnouncementOrder.Date: apartments = apartments.OrderBy(a => a.Created); break;
case AnnouncementOrder.DateDescending: apartments = apartments.OrderByDescending(a => a.Created); break;
default: apartments = apartments.OrderBy(a => a.Address.ToString()); break;
}
if (ModelState.IsValid)
{
if (filter != null)
{
if (filter.IsEmpty() && considerEmpty)
{
ApartmentFilterCriteria newFilter = ObjectToCookie.GetObjectFromCookies <ApartmentFilterCriteria>(Request.Cookies, COOKIE_KEY_APARTMENTFILTER);
if (newFilter != null)
{
filter = newFilter;
}
}
apartments = filter.Filter(apartments);
ObjectToCookie.SetCookieAsObject <ApartmentFilterCriteria>(filter, Response.Cookies, COOKIE_KEY_APARTMENTFILTER);
}
}
else
{
filter = new ApartmentFilterCriteria();
}
ViewBag.ViewType = viewtype;
ViewBag.Type = type;
ViewBag.OrderType = order;
if (viewtype == NavigationViewType.List)
{
ApartmentsListViewModel viewModel = new ApartmentsListViewModel();
viewModel.Page = createPageInfo(page, apartments.Count());
setViewModel(viewModel, announcementsForPage(apartments, page));
viewModel.FilterCriteria = filter;
return(View("Apartments", viewModel));
}
else
{
ApartmentsViewModel viewModel = new ApartmentsViewModel();
setViewModel(viewModel, apartments);
viewModel.FilterCriteria = filter;
return(View("ApartmentsMap", viewModel));
}
}
public void EventOccurred(AnnouncementType type, AudioPriority priority, float expirationTime)
{
if (announcerClips.ContainsKey(type))
{
AudioEvent ae = new AudioEvent(type, priority, Time.time, expirationTime);
waitingClips.Add(ae);
}
}
public ActionResult ClearHouseFilter(AnnouncementType type = AnnouncementType.Buy, NavigationViewType viewtype = NavigationViewType.List, int page = 1)
{
if (Request.Cookies[COOKIE_KEY_HOUSEFILTER] != null)
{
var c = new HttpCookie(COOKIE_KEY_HOUSEFILTER);
c.Expires = DateTime.Now.AddDays(-1);
Response.Cookies.Add(c);
}
return(RedirectToAction("Houses", new { type = type, viewtype = viewtype, page = page }));
}
Color GetColorFor(AnnouncementType aType)
{
for (int i = 0; i < announcementMappings.Count; i++)
{
if (announcementMappings [i].announcementType == aType)
{
return(announcementMappings [i].color);
}
}
return(Color.white);
}
List <AnnouncementList> GetAnnouncementsFor(AnnouncementType aType)
{
for (int i = 0; i < announcementMappings.Count; i++)
{
if (announcementMappings [i].announcementType == aType)
{
return(announcementMappings [i].announcements);
}
}
return(null);
}
public void SetEffect(Vector3 position, float n, Color c, AnnouncementType announcementType)
{
InitializeHitEffect();
start_Alpha = c.a;
SetSpriteColor(c);
CachedTransform.position = position;
announcement = TrashUIManager.Instance.MakeAnnouncement(UIBind, announcementType, n);
}
/// <summary>
/// 用户是否有操作此通告的权利
/// </summary>
/// <param name="AnnoucementModel"></param>
/// <returns></returns>
public bool isUserHaveAuthority2Announcement(AnnouncementType type, int roleId)
{
RoleModel role = _roleService.SearchRole(roleId);
if (!role.RoleName.Contains("行政") && (type != AnnouncementType.EmployeeeNews || type != AnnouncementType.ActivityMessage))
{
return(false);
}
else
{
return(true);
}
}
public TrashAnnouncement MakeAnnouncement(Transform bind, AnnouncementType announcementType, float n)
{
TrashAnnouncement a = GameObject.Instantiate(prefab_Announcement) as TrashAnnouncement;
a.CachedTransform.SetParent(uiCanvas.transform, false);
a.SetAnnouncement(bind, GetColorFor(announcementType), GetAnnouncementFor(announcementType, n));
if (announcementType != AnnouncementType.Hit)
{
a.AutoDestroy();
}
return(a);
}
private IEnumerable <Announcement> GetAnnouncementsOfType(AnnouncementType announcementType)
{
try
{
var announcementsFromDb = GetAnnouncementsFromDb(announcementType);
return(MapAllToDomainModel(announcementsFromDb));
}
catch (LocalStorageException)
{
throw;
}
catch (Exception ex)
{
throw new DataRepositoryException($"An error occurred while attempting to get the {announcementType} announcements.", ex);
}
}
public async Task <IActionResult> Create([Bind("Id,Text,CreatedBy,CreatedAt,LastUpdatedBy,LastUpdatedAt,IsDeleted,DeletedBy,DeletedAt")] AnnouncementType announcementType)
{
if (ModelState.IsValid)
{
announcementType.CreatedAt = DateTime.UtcNow;
announcementType.LastUpdatedAt = DateTime.UtcNow;
announcementType.CreatedBy = _userManager.GetUserId(HttpContext.User);
announcementType.LastUpdatedBy = _userManager.GetUserId(HttpContext.User);
_context.Add(announcementType);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(announcementType));
}
string GetAnnouncementFor(AnnouncementType announcementType, float n)
{
List <AnnouncementList> announcements = GetAnnouncementsFor(announcementType);
if (announcements == null)
{
Debug.LogError("No announcements found for: " + announcementType.ToString());
return("...");
}
int index = (int)(n * (float)announcements.Count);
index = Mathf.Clamp(index, 0, announcements.Count - 1);
List <string> words = announcements [index].entries;
int i = UnityEngine.Random.Range(0, words.Count);
return(words [i]);
}
void PlayAnnouncerClip(AnnouncementType type)
{
if (!announcerSource.isPlaying)
{
int i = announcerClips[type].GetNextClipIndex();
if (i >= 0 && i < announcerClips[type].clips.Length)
{
announcerSource.clip = announcerClips[type].clips[i];
announcerSource.Play();
prevClipPlayTime = Time.time + announcerSource.clip.length;
//audioClips[type].playCount[i]++;
}
else
{
announcerSource.clip = silence;
}
}
}
public void PlayNextAnnouncerClip()
{
float timeSinceLastClip = Time.time - prevClipPlayTime;
if (timeSinceLastClip > minTimeBetweenClips)
{
if (waitingClips.Count > 0)
{
AudioPriority maxPriority = AudioPriority.NONE;
int maxIndex = -1;
for (int i = 0; i < waitingClips.Count; i++)
{
if (waitingClips[i].priority > maxPriority)
{
maxPriority = waitingClips[i].priority;
maxIndex = i;
}
}
if (maxIndex >= 0)
{
AnnouncementType type = waitingClips[maxIndex].type;
PlayAnnouncerClip(type);
waitingClips.RemoveAt(maxIndex);
}
for (int i = 0; i < waitingClips.Count; i++)
{
if (Time.time > waitingClips[i].timeToExpire + waitingClips[i].timeOccurred)
{
waitingClips.RemoveAt(maxIndex);
}
}
}
}
}
public GenericAnnoucement(string text, AnnouncementType type = AnnouncementType.Other, int priority = 0) : base()
{
Text = text;
Type = type;
Priority = priority;
}
public ActionResult Edit(NotificationModel model)
{
string action = Request["Submit"];
if (action == "cancel")
{
return(RedirectToAction("Index"));
}
if (string.IsNullOrEmpty(model.Title))
{
ModelState.AddModelError("Title", "请输入标题.");
}
if (string.IsNullOrEmpty(model.MessageContent))
{
ModelState.AddModelError("MessageContent", "请输入通知内容.");
}
//model.MessageType = NotificationType.PushMessage;
model.MessageType = NotificationType.Email;
model.CreatedUserId = CommonInstance.GetInstance().LoginUser.Id;
model.Scope = NotificationScope.Public;
model.Title = model.Title;
if (action == "test")
{
//model.Target = "*****@*****.**";
//model.CreatedUserId = CommonInstance.GetInstance().LoginUser.Id;
//model.MessageType = NotificationType.PushMessage;
//model.BusinessType = BusinessType.Approving;
//model.Title = "Missionsky OA Test";
//model.MessageContent = "Kevin Test- to Kevin";
//model.MessagePrams = "test";
//model.Scope = NotificationScope.User;
//model.TargetUserIds = new List<int> { CommonInstance.GetInstance().LoginUser.Id };
}
if (ModelState.IsValid)
{
try
{
AnnouncementType type = AnnouncementType.AdministrationEventAnnounce;
//盘点任务
if (model.BusinessType == BusinessType.AssetInventory)
{
type = AnnouncementType.AssetInventory;
}
var annocumentModel = new AnnouncementModel()
{
Type = type,
Title = model.Title,
Content = model.MessageContent,
ApplyUserId = CommonInstance.GetInstance().LoginUser.Id,
EffectiveDays = 30,
CreateUserId = CommonInstance.GetInstance().LoginUser.Id,
CreatedTime = DateTime.Now,
Status = AnnouncementStatus.AllowPublish,
};
this.AnnouncementService.AddAnnouncement(annocumentModel);
//if (model.BusinessType == BusinessType.AssetInventory)
//{
// int inventoryId = this.AssetInventoryService.AddAssetInventory(new AssetInventoryModel()
// {
// Title = model.Title,
// Description = model.MessageContent,
// Status = AssetInventoryStatus.Open
// });
// model.MessagePrams = inventoryId.ToString();
//}
//bool isProduction = false;
//if (ConfigurationManager.AppSettings["IsProduction"] != null && ConfigurationManager.AppSettings["IsProduction"].ToLower() == "true")
//{
// isProduction = true;
//}
//this.NotificationService.Add(model, isProduction);
////资产盘点发通知后需要创建新的盘点任务
return(RedirectToAction("Index"));
}
catch (Exception ex)
{
ViewBag.Message = ex.Message;
}
}
return(View(model));
}
/// <summary> /// 保存公告 /// </summary> /// <param name="announcementID"></param> /// <param name="postUserID"></param> /// <param name="subject"></param> /// <param name="content"></param> /// <param name="beginDate"></param> /// <param name="endDate"></param> /// <param name="announcementType"></param> /// <returns></returns> public abstract Announcement SaveAnnouncement(int announcementID, int postUserID, string subject, string content, DateTime beginDate, DateTime endDate, AnnouncementType announcementType,int sortOrder);
/// <summary>
/// Get formatted message for corresponding announcement.
/// </summary>
/// <param name="type">Announcement type.</param>
/// <param name="gravestone">Corresponding <see cref="Gravestone"/>.</param>
/// <exception cref="ArgumentOutOfRangeException"><paramref name="type"/> is not a valid type.</exception>
public static string FormatMessage(AnnouncementType type, Gravestone gravestone)
=> type switch
{
public async Task <Announcement> GetRead(int announcementId, AnnouncementType announcementType)
{
var url = $"/{announcementType}/Read.json";
return(await Connector.Get <Announcement>($"{url}?announcementId={announcementId}&announcementType={(int)announcementType}"));
}
public async Task <Announcement> UploadAnnouncementAttachment(int announcementId, AnnouncementType announcementType, string fileName, Stream stream)
{
var url = "/AnnouncementAttachment/UploadAnnouncementAttachment.json";
return(await Connector.Put <Announcement>($"{url}?announcementId={announcementId}&announcementType={(int)announcementType}&filename={fileName}", stream));
}
public void Announce(AnnouncementType announcementType, string message)
{
Console.WriteLine($"[{announcementType.ToString().ToUpper()}] {message}");
}
private IEnumerable <LocalData.Announcement> GetAnnouncementsFromDb(AnnouncementType announcementType)
{
return(DatabaseProvider.QueryDb <LocalData.Announcement>("SELECT * FROM Announcement WHERE Type = ?", announcementType.ToString()).ToList());
}
public async Task <IList <Announcement> > FindAnnouncementsByType(AnnouncementType type)
{
return(await _announcements
.Where(a => a.Type == type)
.ToListAsync());
}
