NovaBryan/EVE_Dump
Log | Files | 📦 下载最新源码 (.zip) | Refs | README

purchase.py (6573B)

      1 #Embedded file name: C:\BuildAgent\work\20d73f1b24eed06e\eve\release\V24.01\packages\characterskills\client\purchase.py
      2 from __future__ import absolute_import
      3 import sys
      4 import carbonui.uiconst as uiconst
      5 import characterskills.common
      6 import evetypes
      7 from .UI.missingSkillbooksWnd import MissingSkillbooksWnd
      8 from player_messaging.client.ui_message import prompt_player_fsd_dialog
      9 from shipfitting.multiBuyUtil import BuyMultipleTypesWithQty
     10 
     11 def dependency(name, injected = None):
     12     if injected is not None:
     13         return injected
     14     return sm.GetService(name)
     15 
     16 
     17 def is_skill_purchase_enabled(macho_net_service = None):
     18     macho_net_service = dependency('machoNet', macho_net_service)
     19     return characterskills.common.is_skill_purchase_enabled(macho_net_service)
     20 
     21 
     22 def purchase_skills(context, skill_type_ids, confirm = True):
     23     context.check_skill_purchase_enabled()
     24     if confirm:
     25         context.prevalidate_purchase(skill_type_ids)
     26         wnd = MissingSkillbooksWnd(context=context)
     27         ret = wnd.ShowModal()
     28         return context.skills_purchased or []
     29     else:
     30         context.validate_purchase(skill_type_ids)
     31         context.send_skill_purchase_request(skill_type_ids)
     32         return context.skills_purchased or []
     33 
     34 
     35 class SkillPurchaseContext(object):
     36 
     37     def __init__(self, macho_net_service = None, skill_service = None, wallet_service = None, skill_plan_template = None):
     38         self.macho_net_service = dependency('machoNet', macho_net_service)
     39         self.skill_service = dependency('skills', skill_service)
     40         self.wallet_service = dependency('wallet', wallet_service)
     41         self.skills_purchased = []
     42         self.validator = SkillPurchaseValidator(skill_service=self.skill_service, wallet_service=self.wallet_service)
     43         self.available_for_purchase = []
     44         self.unavailable_for_purchase = []
     45         self.skill_plan_template = skill_plan_template
     46 
     47     def check_skill_purchase_enabled(self):
     48         characterskills.common.check_skill_purchase_enabled(self.macho_net_service)
     49 
     50     def prevalidate_purchase(self, skill_type_ids):
     51         self.available_for_purchase, self.unavailable_for_purchase = self.validator.prevalidate(skill_type_ids)
     52 
     53     def purchase_available_skills(self):
     54         if self.validate_purchase(self.available_for_purchase):
     55             self.send_skill_purchase_request(self.available_for_purchase)
     56             self.available_for_purchase = []
     57             return True
     58         else:
     59             return False
     60 
     61     def multibuy_all_skills(self):
     62         buyDict = {}
     63         for skill_type_id in self.available_for_purchase:
     64             buyDict[skill_type_id] = 1
     65 
     66         for skill_type_id in self.unavailable_for_purchase:
     67             buyDict[skill_type_id] = 1
     68 
     69         BuyMultipleTypesWithQty(buyDict)
     70 
     71     def multibuy_available_skills(self):
     72         buyDict = {}
     73         for skill_type_id in self.available_for_purchase:
     74             buyDict[skill_type_id] = 1
     75 
     76         BuyMultipleTypesWithQty(buyDict)
     77 
     78     def multibuy_unavailable_skills(self):
     79         buyDict = {}
     80         for skill_type_id in self.unavailable_for_purchase:
     81             buyDict[skill_type_id] = 1
     82 
     83         BuyMultipleTypesWithQty(buyDict)
     84 
     85     def validate_purchase(self, skill_type_ids):
     86         return self.validator.validate(skill_type_ids)
     87 
     88     def send_skill_purchase_request(self, skill_type_ids):
     89         skills_purchased = self.skill_service.GetSkillHandler().PurchaseSkills(skill_type_ids)
     90         self.skills_purchased.extend(skills_purchased)
     91         return True
     92 
     93 
     94 def confirm_skill_purchase(skill_type_ids):
     95     if len(skill_type_ids) == 1:
     96         type_id = skill_type_ids[0]
     97         key = 'ConfirmSkillPurchase_v2'
     98         arguments = {'typeID': type_id,
     99          'cost': characterskills.common.get_direct_purchase_price(type_id)}
    100     else:
    101         key = 'ConfirmMultipleSkillPurchase'
    102         skill_names = [ '- %s' % evetypes.GetName(type_id) for type_id in skill_type_ids ]
    103         arguments = {'cost': sum(map(characterskills.common.get_direct_purchase_price, skill_type_ids)),
    104          'skills': '<br>'.join(skill_names)}
    105     return prompt_player_fsd_dialog(key, arguments, uiconst.YESNO) == uiconst.ID_YES
    106 
    107 
    108 class SkillPurchaseValidator(characterskills.common.SkillPurchaseValidator):
    109 
    110     def __init__(self, skill_service = None, wallet_service = None):
    111         self.skill_service = dependency('skills', skill_service)
    112         self.wallet_service = dependency('wallet', wallet_service)
    113 
    114     def get_account_balance(self):
    115         return self.wallet_service.GetWealth()
    116 
    117     def is_skill_injected(self, skill_type_id):
    118         return self.skill_service.IsSkillInjected(skill_type_id)
    119 
    120     def validate(self, skill_type_ids):
    121         try:
    122             super(SkillPurchaseValidator, self).validate(skill_type_ids)
    123             return True
    124         except Exception as error:
    125             _, _, traceback = sys.exc_info()
    126             characterskills.common.handle_skill_purchase_error(error, traceback)
    127             return False
    128 
    129     def prevalidate(self, skill_type_ids):
    130         skill_type_ids = self._remove_duplicate_skills(skill_type_ids)
    131         skill_type_ids = self._remove_non_skill_type_ids(skill_type_ids)
    132         skill_type_ids = self._remove_skills_already_injected(skill_type_ids)
    133         return self._split_skills_available_for_purchase(skill_type_ids)
    134 
    135     def _remove_duplicate_skills(self, skill_type_ids):
    136         pruned_list = []
    137         for skill_type_id in skill_type_ids:
    138             if skill_type_id not in pruned_list:
    139                 pruned_list.append(skill_type_id)
    140 
    141         return pruned_list
    142 
    143     def _remove_non_skill_type_ids(self, skill_type_ids):
    144         pruned_list = []
    145         for skill_type_id in skill_type_ids:
    146             if self.is_skill(skill_type_id):
    147                 pruned_list.append(skill_type_id)
    148 
    149         return pruned_list
    150 
    151     def _remove_skills_already_injected(self, skill_type_ids):
    152         pruned_list = []
    153         for skill_type_id in skill_type_ids:
    154             if not self.is_skill_injected(skill_type_id):
    155                 pruned_list.append(skill_type_id)
    156 
    157         return pruned_list
    158 
    159     def _split_skills_available_for_purchase(self, skill_type_ids):
    160         available_for_purchase = []
    161         unavailable_for_purchase = []
    162         for skill_type_id in skill_type_ids:
    163             if not self.is_skill_available_for_purchase(skill_type_id):
    164                 unavailable_for_purchase.append(skill_type_id)
    165             else:
    166                 available_for_purchase.append(skill_type_id)
    167 
    168         return (available_for_purchase, unavailable_for_purchase)