void VScrollBarOverlayWindow::MouseUp()
{
RemoveState(ThumbState::MOUSE_DOWN);
current_action_ = ThumbAction::NONE;
UpdateTexture();
ShouldHide();
}
void Game_Battler::RemoveBattleStates() {
std::vector<int16_t>& states = GetStates();
for (size_t i = 0; i < states.size(); ++i) {
if (non_permanent(i + 1) || ReaderUtil::GetElement(Data::states, i + 1)->auto_release_prob > 0) {
RemoveState(i + 1);
}
}
}
void VScrollBarOverlayWindow::ThumbOutsideSlider()
{
if (HasState(ThumbState::INSIDE_SLIDER))
{
RemoveState(ThumbState::INSIDE_SLIDER);
UpdateTexture();
}
}
/// Sets target element as hovered one, removing the flag from all other elements.
void UserInterface::SetHoverElement(UIElement * targetElement)
{
/// Remove the hover flag from all other UIs in the same stack.
RemoveState(UIState::HOVER);
if (!targetElement)
return;
/// Then add it to our specified one.
targetElement->AddState(UIState::HOVER);
targetElement->EnsureVisibility();
targetElement->OnHover();
}
nsresult
nsSiteSecurityService::SetState(uint32_t aType,
nsIURI* aSourceURI,
int64_t maxage,
bool includeSubdomains,
uint32_t flags)
{
// If max-age is zero, that's an indication to immediately remove the
// permissions, so here's a shortcut.
if (!maxage) {
return RemoveState(aType, aSourceURI, flags);
}
// Expire time is millis from now. Since STS max-age is in seconds, and
// PR_Now() is in micros, must equalize the units at milliseconds.
int64_t expiretime = (PR_Now() / PR_USEC_PER_MSEC) +
(maxage * PR_MSEC_PER_SEC);
bool isPrivate = flags & nsISocketProvider::NO_PERMANENT_STORAGE;
// record entry for this host with max-age in the permissions manager
SSSLOG(("SSS: maxage permission SET, adding permission\n"));
nsresult rv = AddPermission(aSourceURI,
STS_PERMISSION,
(uint32_t) STS_SET,
(uint32_t) nsIPermissionManager::EXPIRE_TIME,
expiretime,
isPrivate);
NS_ENSURE_SUCCESS(rv, rv);
if (includeSubdomains) {
// record entry for this host with include subdomains in the permissions manager
SSSLOG(("SSS: subdomains permission SET, adding permission\n"));
rv = AddPermission(aSourceURI,
STS_SUBDOMAIN_PERMISSION,
(uint32_t) STS_SET,
(uint32_t) nsIPermissionManager::EXPIRE_TIME,
expiretime,
isPrivate);
NS_ENSURE_SUCCESS(rv, rv);
} else { // !includeSubdomains
nsAutoCString hostname;
rv = GetHost(aSourceURI, hostname);
NS_ENSURE_SUCCESS(rv, rv);
SSSLOG(("SSS: subdomains permission UNSET, removing any existing ones\n"));
rv = RemovePermission(hostname, STS_SUBDOMAIN_PERMISSION, isPrivate);
NS_ENSURE_SUCCESS(rv, rv);
}
return NS_OK;
}
void Game_Actor::RemoveEquipmentState(const RPG::Item& item) {
if (!Player::IsRPG2k3()) {
return;
}
if (item.state_effect) {
for (int i = 0; i < (int)item.state_set.size(); i++) {
if (item.state_set[i]) {
RemoveState(i + 1);
}
}
}
AddEquipmentStates();
}
bool Game_Battler::UseSkill(int skill_id) {
const RPG::Skill* skill = ReaderUtil::GetElement(Data::skills, skill_id);
if (!skill) {
Output::Warning("UseSkill: Can't use skill with invalid ID %d", skill_id);
return false;
}
bool was_used = false;
if (skill->type == RPG::Skill::Type_normal || skill->type >= RPG::Skill::Type_subskill) {
// Only takes care of healing skills outside of battle,
// the other skill logic is in Game_BattleAlgorithm
if (!(skill->scope == RPG::Skill::Scope_ally ||
skill->scope == RPG::Skill::Scope_party ||
skill->scope == RPG::Skill::Scope_self)) {
return false;
}
// Skills only increase hp and sp outside of battle
if (skill->power > 0 && skill->affect_hp && !HasFullHp()) {
was_used = true;
ChangeHp(skill->power);
}
if (skill->power > 0 && skill->affect_sp && !HasFullSp()) {
was_used = true;
ChangeSp(skill->power);
}
for (int i = 0; i < (int) skill->state_effects.size(); i++) {
if (skill->state_effects[i]) {
if (skill->state_effect) {
was_used |= !HasState(Data::states[i].ID);
AddState(Data::states[i].ID);
} else {
was_used |= HasState(Data::states[i].ID);
RemoveState(Data::states[i].ID);
}
}
}
} else if (skill->type == RPG::Skill::Type_teleport || skill->type == RPG::Skill::Type_escape) {
was_used = true;
} else if (skill->type == RPG::Skill::Type_switch) {
Game_Switches[skill->switch_id] = true;
was_used = true;
}
return was_used;
}
bool Game_Battler::UseSkill(int skill_id) {
const RPG::Skill& skill = Data::skills[skill_id - 1];
bool was_used = false;
switch (skill.type) {
case RPG::Skill::Type_normal:
case RPG::Skill::Type_subskill:
// Only takes care of healing skills outside of battle,
// the other skill logic is in Game_BattleAlgorithm
if (!(skill.scope == RPG::Skill::Scope_ally ||
skill.scope == RPG::Skill::Scope_party ||
skill.scope == RPG::Skill::Scope_self)) {
return false;
}
// Skills only increase hp and sp outside of battle
if (skill.power > 0 && skill.affect_hp && !HasFullHp()) {
was_used = true;
ChangeHp(skill.power);
}
if (skill.power > 0 && skill.affect_sp && !HasFullSp()) {
was_used = true;
ChangeSp(skill.power);
}
for (int i = 0; i < (int)skill.state_effects.size(); i++) {
if (skill.state_effects[i]) {
if (skill.state_effect) {
was_used |= !HasState(Data::states[i].ID);
AddState(Data::states[i].ID);
} else {
was_used |= HasState(Data::states[i].ID);
RemoveState(Data::states[i].ID);
}
}
}
case RPG::Skill::Type_teleport:
case RPG::Skill::Type_escape:
// ToDo: Show Teleport/Escape target menu
break;
case RPG::Skill::Type_switch:
Game_Switches[skill.switch_id] = true;
return true;
}
return was_used;
}
void Game_Enemy::ChangeHp(int hp) {
SetHp(GetHp() + hp);
if (this->hp == 0) {
// Death
SetGauge(0);
SetDefending(false);
SetCharged(false);
RemoveAllStates();
AddState(1);
} else {
// Back to life
RemoveState(1);
}
}
bool OOPLyric::Resume() {
// 不能在停止状态下调用本函数
wxASSERT(!TestState(OLST_STOPPED));
// 必须先进入 StartLyric()
if (!TestState(OLST_STARTED) || m_timer.IsRunning()) {
return false;
}
RemoveState(OLST_PAUSED);
//--------------------------------------------------------
m_timer.Start(REFRESH_INTERVAL_MS);
return true;
}
std::vector<int16_t> Game_Battler::BattleStateHeal() {
std::vector<int16_t> healed_states;
std::vector<int16_t>& states = GetStates();
for (size_t i = 0; i < states.size(); ++i) {
if (HasState(i + 1)) {
if (states[i] > Data::states[i].hold_turn
&& Utils::ChanceOf(Data::states[i].auto_release_prob, 100)) {
healed_states.push_back(i + 1);
RemoveState(i + 1);
} else {
++states[i];
}
}
}
return healed_states;
}
bool Game_Battler::UseItem(int item_id) {
const RPG::Item& item = Data::items[item_id - 1];
if (item.type == RPG::Item::Type_medicine) {
int hp_change = item.recover_hp_rate * GetMaxHp() / 100 + item.recover_hp;
int sp_change = item.recover_sp_rate * GetMaxSp() / 100 + item.recover_sp;
if (IsDead()) {
// Check if item can revive
if (item.state_set.empty() || !item.state_set[0]) {
return false;
}
// Revive gives at least 1 Hp
if (hp_change == 0) {
ChangeHp(1);
}
} else if (item.ko_only) {
// Must be dead
return false;
}
ChangeHp(hp_change);
SetSp(GetSp() + sp_change);
for (std::vector<bool>::const_iterator it = item.state_set.begin();
it != item.state_set.end(); ++it) {
if (*it) {
RemoveState(*it);
}
}
// TODO
return true;
} else if (item.type == RPG::Item::Type_material) {
// TODO
return false;
}
return false;
}
std::vector<int16_t> Game_Battler::BattlePhysicalStateHeal(int physical_rate) {
std::vector<int16_t> healed_states;
std::vector<int16_t>& states = GetStates();
if (physical_rate <= 0) {
return healed_states;
}
for (size_t i = 0; i < states.size(); ++i) {
if (HasState(i + 1) && Data::states[i].release_by_damage > 0) {
int release_chance = (int)(Data::states[i].release_by_damage * physical_rate / 100.0);
if (Utils::ChanceOf(release_chance, 100)) {
healed_states.push_back(i + 1);
RemoveState(i + 1);
}
}
}
return healed_states;
}
std::vector<int16_t> Game_Battler::NextBattleTurn() {
++battle_turn;
std::vector<int16_t> healed_states;
std::vector<int16_t>& states = GetStates();
for (size_t i = 0; i < states.size(); ++i) {
if (HasState(i + 1)) {
states[i] += 1;
if (states[i] >= Data::states[i].hold_turn) {
if (Utils::ChanceOf(Data::states[i].auto_release_prob, 100)) {
healed_states.push_back(i + 1);
RemoveState(i + 1);
}
}
}
}
return healed_states;
}
void OOPLyric::Start() {
if (!IsOk()) {
wxLogError(L"歌词控件尚未正确初始化。");
return;
}
// 不能两次进入本函数
if (TestState(OLST_STARTED)) {
if (m_stopWatch->IsRunning()) {
Resume();
}
return;
}
SetAddinState(OLST_STARTED);
RemoveState(OLST_STOPPED | OLST_PAUSED);
//======================================================
UpdateProgress(NULL);
}
void VScrollBarOverlayWindow::MouseBeyond()
{
RemoveState(ThumbState::MOUSE_NEAR);
ShouldHide();
}
void OOPLyric::OnMouseEvent(VdkMouseEvent &e) {
switch (e.evtCode) {
case RIGHT_UP: {
// 拖动歌词时不要响应右键事件
if (TestState(OLST_DRAGGING)) {
return;
}
wxPoint menuPos(AbsoluteRect().GetPosition());
menuPos.x += e.mousePos.x;
menuPos.y += e.mousePos.y;
m_Window->ShowContextMenu(this, menuPos);
break;
}
case LEFT_DOWN: {
m_draggDistance = e.mousePos.y;
SetAddinState(OLST_DRAGGING_STARTED);
break;
}
case DRAGGING: {
// 不接受先在一首歌的会话中拖动歌词，然后在未释放鼠标的情况下
// 另一首歌开始播放，继续前面的拖动事件
if (!TestState(OLST_DRAGGING_STARTED)) {
break;
}
if (!IsOk()) {
break;
}
if (m_timer.IsRunning()) {
Pause();
SetAddinState(OLST_RUNNING_BEFORE_DRAGGING);
}
SetAddinState(OLST_DRAGGING);
//======================================================
int ystart;
GetViewStartCoord(NULL, &ystart);
int dY = e.mousePos.y - m_draggDistance;
m_draggDistance = e.mousePos.y;
// 这是一行我们手工加上去的空行
int rowHeight = GetRowHeight();
int upperBound =
(*(m_parser->begin()))->GetLyric().empty() ? rowHeight : 0;
// 无法继续将帘布向上卷(再拖下去就到下一首了)
// 我们将拖到尽头的事件视为无效
bool lastLine = false;
// 情景：将虚拟画布像窗帘一样向下拖
// 拖动尽头了，不能再把窗帘哪怕拖下一寸
if (ystart - dY < upperBound) {
dY = ystart - upperBound; // 加加减减的原因参照(*)
} else {
int maxy;
GetMaxViewStartCoord(NULL, &maxy);
// 将帘布向上卷，卷到尽头了，再卷下去就会导致
// 无法完整遮住窗口
if (ystart - dY > maxy) {
dY = ystart - maxy; // 加加减减的原因参照(*)
// 无效拖动事件
lastLine = true;
}
}
if (dY) {
SetViewStart(0, ystart - dY, &e.dc); //………………(*)
}
// 无效拖动事件
if (lastLine) {
m_draggHit = m_parser->end();
}
//===================================================
// 绘制中间线段
wxRect rc(GetAbsoluteRect());
int y = rc.y + m_blankLinesTop * GetRowHeight();
m_Window->ResetDcOrigin(e.dc);
e.dc.SetPen(wxPen(m_TextColor));
e.dc.DrawLine(rc.x, y, rc.GetRight(), y);
break;
}
case NORMAL:
case LEFT_UP: {
if (!TestState(OLST_DRAGGING) ||
!TestState(OLST_DRAGGING_STARTED)) {
break;
}
wxASSERT(IsOk());
//-----------------------------------------------------
RemoveState(OLST_DRAGGING | OLST_DRAGGING_STARTED);
// 拖到最下面了，尽头
if (m_draggHit == m_parser->end()) {
RefreshState(&e.dc);
} else {
int ystart; // 起始绘图坐标
GetViewStartCoord(NULL, &ystart);
LineInfo *lineDraggHit = *m_draggHit;
size_t timeToGo = lineDraggHit->GetStartTime();
int rowHeight = GetRowHeight();
double linePercentage = double(ystart % rowHeight) / rowHeight ;
timeToGo += lineDraggHit->GetMilSeconds() * linePercentage;
// 歌词可能并不匹配正在播放的歌曲
if (timeToGo < m_parser->GetTimeSum()) {
m_currLine = m_draggHit;
if (IsReadyForEvent()) {
FireEvent(&e.dc, (void *) timeToGo);
}
}
}
bool resume = TestState(OLST_RUNNING_BEFORE_DRAGGING);
if (resume) {
RemoveState(OLST_RUNNING_BEFORE_DRAGGING);
Resume();
}
break;
}
default:
break;
}
}
bool Game_Battler::UseItem(int item_id, const Game_Battler* source) {
const RPG::Item* item = ReaderUtil::GetElement(Data::items, item_id);
if (!item) {
Output::Warning("UseItem: Can't use item with invalid ID %d", item_id);
return false;
}
if (item->type == RPG::Item::Type_medicine) {
bool was_used = false;
int revived = 0;
int hp_change = item->recover_hp_rate * GetMaxHp() / 100 + item->recover_hp;
int sp_change = item->recover_sp_rate * GetMaxSp() / 100 + item->recover_sp;
if (IsDead()) {
// Check if item can revive
if (item->state_set.empty() || !item->state_set[0]) {
return false;
}
} else if (item->ko_only) {
// Must be dead
return false;
}
for (int i = 0; i < (int)item->state_set.size(); i++) {
if (item->state_set[i]) {
was_used |= HasState(Data::states[i].ID);
if (i == 0 && HasState(i + 1))
revived = 1;
RemoveState(Data::states[i].ID);
}
}
if (hp_change > 0 && !HasFullHp()) {
ChangeHp(hp_change - revived);
was_used = true;
}
if (sp_change > 0 && !HasFullSp()) {
ChangeSp(sp_change);
was_used = true;
}
return was_used;
}
if (item->type == RPG::Item::Type_switch) {
return true;
}
bool do_skill = (item->type == RPG::Item::Type_special)
|| (item->use_skill && (
item->type == RPG::Item::Type_weapon
|| item->type == RPG::Item::Type_shield
|| item->type == RPG::Item::Type_armor
|| item->type == RPG::Item::Type_helmet
|| item->type == RPG::Item::Type_accessory
)
);
if (do_skill) {
auto* skill = ReaderUtil::GetElement(Data::skills, item->skill_id);
if (skill == nullptr) {
Output::Warning("UseItem: Can't use item %d skill with invalid ID %d", item->ID, item->skill_id);
return false;
}
UseSkill(item->skill_id, source);
}
return false;
}
void Animatable::RemoveState(const String& name)
{
RemoveState(GetState(name));
}
void StateManager::ProcessRequests(){
while (m_toRemove.begin() != m_toRemove.end()){
RemoveState(*m_toRemove.begin());
m_toRemove.erase(m_toRemove.begin());
}
}
void VScrollBarOverlayWindow::MouseLeave()
{
RemoveState(ThumbState::MOUSE_INSIDE);
ShouldHide();
}
bool Game_Battler::UseSkill(int skill_id, const Game_Battler* source) {
const RPG::Skill* skill = ReaderUtil::GetElement(Data::skills, skill_id);
if (!skill) {
Output::Warning("UseSkill: Can't use skill with invalid ID %d", skill_id);
return false;
}
bool cure_hp_percentage = false;
bool was_used = false;
if (skill->type == RPG::Skill::Type_normal || skill->type >= RPG::Skill::Type_subskill) {
// Only takes care of healing skills outside of battle,
// the other skill logic is in Game_BattleAlgorithm
if (!(skill->scope == RPG::Skill::Scope_ally ||
skill->scope == RPG::Skill::Scope_party ||
skill->scope == RPG::Skill::Scope_self)) {
return false;
}
// Calculate effect:
float mul = GetAttributeMultiplier(skill->attribute_effects);
int effect = skill->power;
if (source != nullptr) {
effect += source->GetAtk() * skill->physical_rate / 20 +
source->GetSpi() * skill->magical_rate / 40;
}
effect *= mul;
effect += (effect * Utils::GetRandomNumber(-skill->variance * 10, skill->variance * 10) / 100);
if (effect < 0)
effect = 0;
// Cure states
for (int i = 0; i < (int)skill->state_effects.size(); i++) {
if (skill->state_effects[i]) {
if (skill->reverse_state_effect) {
was_used |= !HasState(Data::states[i].ID);
AddState(Data::states[i].ID);
}
else {
was_used |= HasState(Data::states[i].ID);
RemoveState(Data::states[i].ID);
// If Death is cured and HP is not selected, we set a bool so it later heals HP percentage
if (i == 0 && !skill->affect_hp) {
cure_hp_percentage = true;
}
}
}
}
// Skills only increase hp and sp outside of battle
if (effect > 0 && skill->affect_hp && !HasFullHp() && !IsDead()) {
was_used = true;
ChangeHp(effect);
}
else if (effect > 0 && cure_hp_percentage) {
was_used = true;
ChangeHp(GetMaxHp() * effect / 100);
}
if (effect > 0 && skill->affect_sp && !HasFullSp() && !IsDead()) {
was_used = true;
ChangeSp(effect);
}
} else if (skill->type == RPG::Skill::Type_teleport || skill->type == RPG::Skill::Type_escape) {
Game_System::SePlay(skill->sound_effect);
was_used = true;
} else if (skill->type == RPG::Skill::Type_switch) {
Game_System::SePlay(skill->sound_effect);
Game_Switches.Set(skill->switch_id, true);
was_used = true;
}
return was_used;
}
bool Game_Battler::UseItem(int item_id) {
const RPG::Item* item = ReaderUtil::GetElement(Data::items, item_id);
if (!item) {
Output::Warning("UseItem: Can't use item with invalid ID %d", item_id);
return false;
}
if (item->type == RPG::Item::Type_medicine) {
bool was_used = false;
int hp_change = item->recover_hp_rate * GetMaxHp() / 100 + item->recover_hp;
int sp_change = item->recover_sp_rate * GetMaxSp() / 100 + item->recover_sp;
if (IsDead()) {
// Check if item can revive
if (item->state_set.empty() || !item->state_set[0]) {
return false;
}
// Revive gives at least 1 Hp
if (hp_change == 0) {
ChangeHp(1);
was_used = true;
}
} else if (item->ko_only) {
// Must be dead
return false;
}
if (hp_change > 0 && !HasFullHp()) {
ChangeHp(hp_change);
was_used = true;
}
if (sp_change > 0 && !HasFullSp()) {
ChangeSp(sp_change);
was_used = true;
}
for (int i = 0; i < (int)item->state_set.size(); i++) {
if (item->state_set[i]) {
was_used |= HasState(Data::states[i].ID);
RemoveState(Data::states[i].ID);
}
}
return was_used;
}
if (item->type == RPG::Item::Type_switch) {
return true;
}
switch (item->type) {
case RPG::Item::Type_weapon:
case RPG::Item::Type_shield:
case RPG::Item::Type_armor:
case RPG::Item::Type_helmet:
case RPG::Item::Type_accessory:
return item->use_skill && UseSkill(item->skill_id);
case RPG::Item::Type_special:
return UseSkill(item->skill_id);
}
return false;
}
