Пример #1
0
        private void EditReward(int fileid, int blockid, int triggerid, int rewardid, Reward reward)
        {
            TreeNode node = tree.Nodes[fileid].Nodes[blockid].Nodes[triggerid].Nodes[1].Nodes[rewardid];

            node.Tag  = reward.Clone();
            node.Text = Reward.getNodeText(reward);
            form.SelectNode(node.Parent.Parent);
        }
Пример #2
0
        public static string getNodeText(Reward r)
        {
            switch (r.getRewardType())
            {
            case RewardType.REWD000:
                return(string.Format("{0} Quest {1}", ((Rewd000)r).Operator.getText(), ((Rewd000)r).questid));

            case RewardType.REWD001:
                return(string.Format("{0} Item {1} x {2}", ((Rewd001)r).Action.getText(), ((Rewd001)r).Amount, ((Rewd001)r).ItemSN));

            case RewardType.REWD002:
            {
                if (((Rewd002)r).data.Length == 1)
                {
                    return(string.Format("Quest: {0}({1}) {2} {3}", ((Rewd002)r).data[0].VarType.getText(), ((Rewd002)r).data[0].VarNo, ((Rewd002)r).data[0].op.getText(), ((Rewd002)r).data[0].Value));
                }
                else
                {
                    return(string.Format("QuestVars: {0}", ((Rewd002)r).data.Length));
                }
            }

            case RewardType.REWD003:
            {
                if (((Rewd003)r).data.Length == 1)
                {
                    return(string.Format("Ability: {0} {1} {2}", ((Rewd003)r).data[0].type.getText(), ((Rewd003)r).data[0].op.getText(), ((Rewd003)r).data[0].value));
                }
                else
                {
                    return(string.Format("Abilities: {0}", ((Rewd003)r).data.Length));
                }
            }

            case RewardType.REWD004:
            {
                if (((Rewd004)r).data.Length == 1)
                {
                    return(string.Format("User: {0}({1}) {2} {3}", ((Rewd004)r).data[0].VarType.getText(), ((Rewd004)r).data[0].VarNo, ((Rewd004)r).data[0].op.getText(), ((Rewd004)r).data[0].Value));
                }
                else
                {
                    return(string.Format("UserVars: {0}", ((Rewd004)r).data.Length));
                }
            }

            case RewardType.REWD005:
            {
                if (((Rewd005)r).Target == ItemRewardType.Experience)
                {
                    return(string.Format("Reward Experience: {0}", ((Rewd005)r).Value));
                }
                else if (((Rewd005)r).Target == ItemRewardType.Money)
                {
                    return(string.Format("Reward Zulie: {0}", ((Rewd005)r).Value));
                }
                else
                {
                    return(string.Format("Reward Item: {0} x {1}", ((Rewd005)r).Value, ((Rewd005)r).ItemSN));
                }
            }

            case RewardType.REWD006:
                return(string.Format("Set HP({0}%) and MP({1}%)", ((Rewd006)r).PercentOfHP, ((Rewd006)r).PercentOfMP));

            case RewardType.REWD007:
                return(string.Format("Warp to Zone {0} ({1},{2}) Party: {3}", ((Rewd007)r).ZoneNo, ((Rewd007)r).X, ((Rewd007)r).Y, ((Rewd007)r).PartyOpt));

            case RewardType.REWD008:
                return(string.Format("Spawn {1} of mob ID {2} at {0}", ((Rewd008)r).Where.getText(), ((Rewd008)r).HowMany, ((Rewd008)r).MonsterID));

            case RewardType.REWD009:
                return(string.Format("Set Next Trigger: {0}", ((Rewd009)r).NextTriggerSN));

            case RewardType.REWD010:
                return(string.Format("Reset Stats"));

            case RewardType.REWD011:
                return(string.Format("Set {0} Var {1} {2} {3}", ((Rewd011)r).Who.getText(), ((Rewd011)r).VarNo, ((Rewd011)r).Operator.getText(), ((Rewd011)r).Value));

            case RewardType.REWD012:
                return(string.Format("NPC {0} Message {1}", ((Rewd012)r).MsgType.getText(), ((Rewd012)r).StringID));

            case RewardType.REWD013:
                return(string.Format("Set Next {0} Trigger: {1}", ((Rewd013)r).Who.getText(), ((Rewd013)r).Trigger));

            case RewardType.REWD014:
                return(string.Format("{0} Skill {1}", ((Rewd014)r).Operator.getText(), ((Rewd014)r).SkillNo));

            case RewardType.REWD015:
                return(string.Format("Set Switch {0} {1}", ((Rewd015)r).QuestSwitch, ((Rewd015)r).OnOff.getText()));

            case RewardType.REWD016:
                return(string.Format("Reset SwitchGroup {0}", ((Rewd016)r).QuestSwitchGroup));

            case RewardType.REWD017:
                return(string.Format("Reset All Switches"));

            case RewardType.REWD018:
                return(string.Format("NPC Announce String {0}", ((Rewd018)r).StrID));

            case RewardType.REWD019:
                return(string.Format("Zone {0} Do Trigger: {1}, Team {2}", ((Rewd019)r).ZoneNo, ((Rewd019)r).TriggerName, ((Rewd019)r).TeamNo));

            case RewardType.REWD020:
                return(string.Format("Set Team by {0}", ((Rewd020)r).TeamType.getText()));

            case RewardType.REWD021:
                return(string.Format("Set Revive Position: {0}, {1}", ((Rewd021)r).X, ((Rewd021)r).Y));

            case RewardType.REWD022:
                return(string.Format("Zone {0} Regen Mode: {1}", ((Rewd022)r).ZoneNo, ((Rewd022)r).Operator.getText()));

            case RewardType.REWD023:
                return(string.Format("Increase Clan Level"));

            case RewardType.REWD024:
                return(string.Format("Clan Money {0} {1}", ((Rewd024)r).Operator.getText(), ((Rewd024)r).ClanMoney));

            case RewardType.REWD025:
                return(string.Format("Clan Points {0} {1}", ((Rewd025)r).Operator.getText(), ((Rewd025)r).ClanPoints));

            case RewardType.REWD026:
                return(string.Format("Clan Skill {0} {1}", ((Rewd026)r).Operator.getText(), ((Rewd026)r).ClanSkillNo));

            case RewardType.REWD027:
                return(string.Format("Clan Contribute (bugged) {0} {1}", ((Rewd027)r).Operator.getText(), ((Rewd027)r).ClanContribute));

            case RewardType.REWD028:
                return(string.Format("Warp ClanMembers in Range to {0} {1}, {2}", ((Rewd028)r).ZoneNo, ((Rewd028)r).X, ((Rewd028)r).Y));

            case RewardType.REWD029:
                return(string.Format("Run Lua Function {0}", ((Rewd029)r).ScriptName));

            case RewardType.REWD030:
                return(string.Format("Reset Skills"));

            case RewardType.REWD031:
                return(string.Format("Set QuestVar {0} (???)", ((Rewd031)r).Var.VarNo));

            case RewardType.REWD032:
                return(string.Format("Reward Item {0}", ((Rewd032)r).ItemSN));

            case RewardType.REWD033:
                return(string.Format("/"));

            case RewardType.REWD034:
                return(string.Format("NPC Visibility: {0}", ((Rewd034)r).HideShowToggle));

            /* Custom Rewards */
            case RewardType.REWD050:
                return(string.Format("Reward from Break: {0}", ((Rewd050)r).BreakID));

            case RewardType.REWD051:
                return(string.Format("Write Message: {0}> {1}", ((Rewd051)r).MsgType.getText(), ((Rewd051)r).Message));

            case RewardType.REWD052:
                return(string.Format("Set Quest Switch at NPC EventValue index: {0}", ((Rewd052)r).On.getText()));

            default:
                return("Unknown Reward " + (int)r.getRewardType());
            }
        }
Пример #3
0
        object[] GetObjectCellOrder(object o)
        {
            if (o is Condition)
            {
                Condition c = (Condition)o;
                switch (c.getConditionType())
                {
                case ConditionType.COND000:
                    return(new object[] { "Quest ID:", pr(() => ((Cond000)c).questid) });

                case ConditionType.COND001:
                    return(new object[] { "Quest Checks:", pr(() => ((Cond001)c).data) });

                case ConditionType.COND002:
                    return(new object[] { "Variable Checks:", pr(() => ((Cond002)c).data) });

                case ConditionType.COND003:
                    return(new object[] { "Ability Checks:", pr(() => ((Cond003)c).data) });

                case ConditionType.COND004:
                    return(new object[] { "Item Checks:", pr(() => ((Cond004)c).data) });

                case ConditionType.COND005:
                    return(new object[] { "Minimum party level:", pr(() => ((Cond005)c).MinimumLevel), null,
                                          "Party leader", pr(() => ((Cond005)c).IsLeader) });

                case ConditionType.COND006:
                    return(new object[] { "Zone:", pr(() => ((Cond006)c).ZoneNo), null,
                                          "X:", pr(() => ((Cond006)c).Y), null,
                                          "Y:", pr(() => ((Cond006)c).Y), null,
                                          "Range:", pr(() => ((Cond006)c).Radius) });

                case ConditionType.COND007:     // unused
                    return(new object[] { });

                case ConditionType.COND008:
                    return(new object[] { pr(() => ((Cond008)c).Operator), pr(() => ((Cond008)c).Time) });

                case ConditionType.COND009:
                    return(new object[] { "Skill between:", pr(() => ((Cond009)c).SkillNo1), "and", pr(() => ((Cond009)c).SkillNo2), null,
                                          "Has skill?", pr(() => ((Cond009)c).Operator) });

                case ConditionType.COND010:
                    return(new object[] { "Random percent between:", pr(() => ((Cond010)c).MinimumPercent), "and", pr(() => ((Cond010)c).MaximumPercent) });

                case ConditionType.COND011:
                    return(new object[] { "Type:", pr(() => ((Cond011)c).Who), null,
                                          "Var:", pr(() => ((Cond011)c).VarNo), pr(() => ((Cond011)c).Operator), pr(() => ((Cond011)c).Value) });

                case ConditionType.COND012:
                    return(new object[] { "Zone:", pr(() => ((Cond012)c).Zone), null,
                                          "X:", pr(() => ((Cond012)c).X), null,
                                          "Y:", pr(() => ((Cond012)c).Y), null,
                                          "Event ID:", pr(() => ((Cond012)c).EventID) });

                case ConditionType.COND013:
                    return(new object[] { "NPC:", pr(() => ((Cond013)c).NpcNo) });

                case ConditionType.COND014:
                    return(new object[] { "Switch:", pr(() => ((Cond014)c).SwitchNo), pr(() => ((Cond014)c).Operator) });

                case ConditionType.COND015:
                    return(new object[] { "Member count from:", pr(() => ((Cond015)c).Number1), "to", pr(() => ((Cond015)c).Number2) });

                case ConditionType.COND016:
                    return(new object[] { "Type:", pr(() => ((Cond016)c).Who), null,
                                          "Start time:", pr(() => ((Cond016)c).TimeStart), null,
                                          "End time:", pr(() => ((Cond016)c).TimeEnd) });

                case ConditionType.COND017:
                    return(new object[] { "NPC:", pr(() => ((Cond017)c).npcno1),
                                          "Var:", pr(() => ((Cond017)c).varno1),
                                          pr(() => ((Cond017)c).Operator),
                                          "NPC:", pr(() => ((Cond017)c).npcno2),
                                          "Var:", pr(() => ((Cond017)c).varno2) });

                case ConditionType.COND018:
                    return(new object[] { "Day:", pr(() => ((Cond018)c).DayOfMonth), null,
                                          "Time:", pr(() => ((Cond018)c).HourLow), ":", pr(() => ((Cond018)c).MinuteLow),
                                          "-", pr(() => ((Cond018)c).HourHigh), ":", pr(() => ((Cond018)c).MinuteHigh) });

                case ConditionType.COND019:     // unused
                    return(new object[] { });

                case ConditionType.COND020:     // unused
                    return(new object[] { });

                case ConditionType.COND021:
                    return(new object[] { "Maximum distance to selected", pr(() => ((Cond021)c).ObjectType), pr(() => ((Cond021)c).Radius) });

                case ConditionType.COND022:
                    return(new object[] { "Channel is between", pr(() => ((Cond022)c).Min), "and", pr(() => ((Cond022)c).Max) });

                case ConditionType.COND023:
                    return(new object[] { "User has a clan?", pr(() => ((Cond023)c).Operator) });

                case ConditionType.COND024:
                    return(new object[] { "Rank in clan", pr(() => ((Cond024)c).Operator), pr(() => ((Cond024)c).ClanPos) });

                case ConditionType.COND025:
                    return(new object[] { "Clan contribution:", pr(() => ((Cond025)c).Operator), pr(() => ((Cond025)c).ClanContribute) });

                case ConditionType.COND026:
                    return(new object[] { "Clan grade:", pr(() => ((Cond026)c).Operator), pr(() => ((Cond026)c).ClanGrade) });

                case ConditionType.COND027:
                    return(new object[] { "Clan points:", pr(() => ((Cond027)c).Operator), pr(() => ((Cond027)c).ClanPoint) });

                case ConditionType.COND028:
                    return(new object[] { "Clan money:", pr(() => ((Cond028)c).Operator), pr(() => ((Cond028)c).ClanMoney) });

                case ConditionType.COND029:
                    return(new object[] { "Clan member count:", pr(() => ((Cond029)c).Operator), pr(() => ((Cond029)c).MemberCount) });

                case ConditionType.COND030:
                    return(new object[] { "Clan skill between:", pr(() => ((Cond030)c).Skill1), "and", pr(() => ((Cond030)c).Skill2), null,
                                          "Clan has skill?", pr(() => ((Cond030)c).Operator) });

                case ConditionType.COND050:
                    return(new object[] { "Quest between", pr(() => ((Cond050)c).Quest1), "and", pr(() => ((Cond050)c).Quest2) });

                case ConditionType.COND051:
                    return(new object[] { "Arena group:", pr(() => ((Cond051)c).Has) });

                case ConditionType.COND052:
                    return(new object[] { "Arena status", pr(() => ((Cond052)c).Operator), "NPC event value" });

                case ConditionType.COND053:
                    return(new object[] { "Switch", pr(() => ((Cond053)c).On) });

                case ConditionType.COND054:
                    return(new object[] { "Arena game:", pr(() => ((Cond054)c).IdOrType), pr(() => ((Cond054)c).Game) });

                default:
                    break;
                }
            }
            else if (o is Reward)
            {
                Reward r = (Reward)o;
                switch (r.getRewardType())
                {
                case RewardType.REWD000:
                    return(new object[] { pr(() => ((Rewd000)r).Operator), pr(() => ((Rewd000)r).questid) });

                case RewardType.REWD001:
                    return(new object[] { pr(() => ((Rewd001)r).Action), pr(() => ((Rewd001)r).Amount), "of item ID", pr(() => ((Rewd001)r).ItemSN) });

                case RewardType.REWD002:
                    return(new object[] { "Quest variables:", pr(() => ((Rewd002)r).data) });

                case RewardType.REWD003:
                    return(new object[] { "Abilities:", pr(() => ((Rewd003)r).data) });

                case RewardType.REWD004:
                    return(new object[] { "User variables:", pr(() => ((Rewd004)r).data) });

                case RewardType.REWD005:
                    return(new object[] { "Give", pr(() => ((Rewd005)r).Value), pr(() => ((Rewd005)r).Target), pr(() => ((Rewd005)r).ItemSN),
                                          "stat:", pr(() => ((Rewd005)r).ItemOpt), "equation:", pr(() => ((Rewd005)r).Equation) });

                case RewardType.REWD006:
                    return(new object[] { "HP%", pr(() => ((Rewd006)r).PercentOfHP),
                                          "MP%", pr(() => ((Rewd006)r).PercentOfMP) });

                case RewardType.REWD007:
                    return(new object[] { pr(() => ((Rewd007)r).PartyOpt), "Zone:", pr(() => ((Rewd007)r).ZoneNo),
                                          "X:", pr(() => ((Rewd007)r).X),
                                          "Y:", pr(() => ((Rewd007)r).Y) });

                case RewardType.REWD008:
                    return(new object[] { "Spawn:", pr(() => ((Rewd008)r).HowMany),
                                          "of mob ID", pr(() => ((Rewd008)r).MonsterID),
                                          "at", pr(() => ((Rewd008)r).Where),
                                          "range:", pr(() => ((Rewd008)r).Range),
                                          "team:", pr(() => ((Rewd008)r).TeamNo),
                                          null,
                                          "Zone:", pr(() => ((Rewd008)r).ZoneNo), "X:", pr(() => ((Rewd008)r).X), "Y:", pr(() => ((Rewd008)r).Y) });

                case RewardType.REWD009:
                    return(new object[] { "Trigger:", pr(() => ((Rewd009)r).NextTriggerSN) });

                case RewardType.REWD010:
                    return(new object[] { "Reset player stats." });

                case RewardType.REWD011:
                    return(new object[] { "Type:", pr(() => ((Rewd011)r).Who), null,
                                          "Var:", pr(() => ((Rewd011)r).VarNo), pr(() => ((Rewd011)r).Operator), pr(() => ((Rewd011)r).Value) });

                case RewardType.REWD012:
                    return(new object[] { pr(() => ((Rewd012)r).MsgType), "String ID:", pr(() => ((Rewd012)r).StringID) });

                case RewardType.REWD013:
                    return(new object[] { "Selected", pr(() => ((Rewd013)r).Who),
                                          "Trigger:", pr(() => ((Rewd013)r).Trigger), "after", pr(() => ((Rewd013)r).Sec), "seconds" });

                case RewardType.REWD014:
                    return(new object[] { pr(() => ((Rewd014)r).Operator), pr(() => ((Rewd014)r).SkillNo) });

                case RewardType.REWD015:
                    return(new object[] { "Switch:", pr(() => ((Rewd015)r).QuestSwitch), pr(() => ((Rewd015)r).OnOff) });

                case RewardType.REWD016:
                    return(new object[] { "Switch group:", pr(() => ((Rewd016)r).QuestSwitchGroup) });

                case RewardType.REWD017:
                    return(new object[] { "Reset player switches." });

                case RewardType.REWD018:
                    return(new object[] { "BUGGED!", pr(() => ((Rewd018)r).StrID) });

                case RewardType.REWD019:
                    return(new object[] { "Zone:", pr(() => ((Rewd019)r).ZoneNo),
                                          "Team:", pr(() => ((Rewd019)r).TeamNo),
                                          "Trigger:", pr(() => ((Rewd019)r).TriggerName) });

                case RewardType.REWD020:
                    return(new object[] { "Team:", pr(() => ((Rewd020)r).TeamType) });

                case RewardType.REWD021:
                    return(new object[] { "X:", pr(() => ((Rewd021)r).X),
                                          "Y:", pr(() => ((Rewd021)r).Y) });

                case RewardType.REWD022:
                    return(new object[] { "Zone:", pr(() => ((Rewd022)r).ZoneNo), "Mob regeneration:", pr(() => ((Rewd022)r).Operator) });

                case RewardType.REWD023:
                    return(new object[] { "Clan level up!" });

                case RewardType.REWD024:
                    return(new object[] { "Clan money:", pr(() => ((Rewd024)r).Operator), pr(() => ((Rewd024)r).ClanMoney) });

                case RewardType.REWD025:
                    return(new object[] { "Clan points:", pr(() => ((Rewd025)r).Operator), pr(() => ((Rewd025)r).ClanPoints) });

                case RewardType.REWD026:
                    return(new object[] { "Clan skill:", pr(() => ((Rewd026)r).Operator), "skill", pr(() => ((Rewd026)r).ClanSkillNo) });

                case RewardType.REWD027:
                    return(new object[] { "Clan contribution:", pr(() => ((Rewd027)r).Operator), pr(() => ((Rewd027)r).ClanContribute) });

                case RewardType.REWD028:
                    return(new object[] { "Zone:", pr(() => ((Rewd028)r).ZoneNo),
                                          "X:", pr(() => ((Rewd028)r).X),
                                          "Y:", pr(() => ((Rewd028)r).Y),
                                          "Range:", pr(() => ((Rewd028)r).Range) });

                case RewardType.REWD029:
                    return(new object[] { "Lua function:", pr(() => ((Rewd029)r).ScriptName) });

                case RewardType.REWD030:
                    return(new object[] { "Reset player skills." });

                case RewardType.REWD031:
                    return(new object[] { "BUGGED!", pr(() => ((Rewd031)r).Var) });

                case RewardType.REWD032:
                    return(new object[] { "BUGGED!", pr(() => ((Rewd032)r).ItemSN), pr(() => ((Rewd032)r).PartyOpt_Bugged) });

                case RewardType.REWD033:
                    return(new object[] { "BUGGED!", pr(() => ((Rewd033)r).NextRewardSplitter) });

                case RewardType.REWD034:
                    return(new object[] { pr(() => ((Rewd034)r).HideShowToggle) });

                case RewardType.REWD050:
                    return(new object[] { "BreakId:", pr(() => ((Rewd050)r).BreakID) });

                case RewardType.REWD051:
                    return(new object[] { "Type:", pr(() => ((Rewd051)r).MsgType), "Msg:", pr(() => ((Rewd051)r).Message) });

                case RewardType.REWD052:
                    return(new object[] { "Switch", pr(() => ((Rewd052)r).On) });

                default:
                    break;
                }
            }
            else if (o is ITEM_DATA_CONDITION)
            {
                ITEM_DATA_CONDITION d = (ITEM_DATA_CONDITION)o;
                return(new object[] { "Item", pr(() => d.itemsn), pr(() => d.op), pr(() => d.cnt), "slot", pr(() => d.equipslot) });
            }
            else if (o is QUEST_DATA_CONDITION)
            {
                QUEST_DATA_CONDITION d = (QUEST_DATA_CONDITION)o;
                return(new object[] { pr(() => d.VarType), pr(() => d.VarNo), pr(() => d.op), pr(() => d.Value) });
            }
            else if (o is ABIL_DATA_CONDITION)
            {
                ABIL_DATA_CONDITION d = (ABIL_DATA_CONDITION)o;
                return(new object[] { pr(() => d.type), pr(() => d.op), pr(() => d.value) });
            }
            else if (o is QUEST_DATA_REWARD)
            {
                QUEST_DATA_REWARD d = (QUEST_DATA_REWARD)o;
                return(new object[] { pr(() => d.VarType), pr(() => d.VarNo), pr(() => d.op), pr(() => d.Value) });
            }
            else if (o is ABIL_DATA_REWARD)
            {
                ABIL_DATA_REWARD d = (ABIL_DATA_REWARD)o;
                return(new object[] { pr(() => d.type), pr(() => d.op), pr(() => d.value) });
            }
            return(new object[] { o });
        }
Пример #4
0
        public void Load(string Filename)
        {
            this.FileName = Filename;

            FileHandler fh = new FileHandler(Filename, FileHandler.FileOpenMode.Reading, Encoding.GetEncoding("EUC-KR"));

            Version = fh.Read <int>();
            int blockCount = fh.Read <int>();

            Title = fh.Read <string>(fh.Read <short>()).Trim('\0');

            for (int i = 0; i < blockCount; i++)
            {
                QuestBlock block = new QuestBlock();

                int triggersCount = fh.Read <int>();
                block.Name = fh.Read <string>(fh.Read <short>()).Trim('\0');

                for (int j = 0; j < triggersCount; j++)
                {
                    QuestTrigger trigger = new QuestTrigger();
                    trigger.CheckNext = (fh.Read <byte>() != 0);
                    int ConditionsCount = fh.Read <int>();
                    int RewardsCount    = fh.Read <int>();
                    trigger.Name = fh.Read <string>(fh.Read <short>()).Trim('\0');

                    for (int c = 0; c < ConditionsCount; c++)
                    {
                        int    size = fh.Read <int>();
                        int    type = fh.Read <int>();
                        byte[] data = fh.Read <byte[]>(size - 8);

                        try
                        {
                            object obj = CreateObject((ConditionType)type);
                            StructReader.Convert(data, ref obj);

                            Condition condition = (Condition)obj;
                            condition.setOriginalData(data);
                            trigger.Conditions.Add(condition);
                        }
                        catch
                        {
                            object    obj       = CreateObject(ConditionType.COND000);
                            Condition condition = (Condition)obj;
                            condition.setOriginalData(data);
                            trigger.Conditions.Add(condition);
                        }
                    }

                    for (int c = 0; c < RewardsCount; c++)
                    {
                        int    size = fh.Read <int>();
                        int    type = fh.Read <int>() & 0x0ffff;
                        byte[] data = fh.Read <byte[]>(size - 8);

                        try
                        {
                            object obj = CreateObject((RewardType)type);
                            StructReader.Convert(data, ref obj);
                            Reward reward = (Reward)obj;
                            reward.setOriginalData(data);
                            trigger.Rewards.Add(reward);
                        }
                        catch
                        {
                            object obj    = CreateObject(RewardType.REWD000);
                            Reward reward = (Reward)obj;
                            reward.setOriginalData(data);
                            trigger.Rewards.Add(reward);
                        }
                    }
                    block.Triggers.Add(trigger);
                }
                this.Blocks.Add(block);
            }
            fh.Close();
        }