Beispiel #1
0
    public override byte[] toBinary()
    {
        writer = new st.net.NetBase.ByteWriter();
        writer.write_int(add_or_remove);
        writer.write_int(thumb_up_num);
        ushort lenfriends_info = (ushort)friends_info.Count;

        writer.write_short(lenfriends_info);
        for (int i_friends_info = 0; i_friends_info < lenfriends_info; i_friends_info++)
        {
            st.net.NetBase.friends_info listData = friends_info[i_friends_info];
            listData.toBinary(writer);
        }
        ushort lenenemy_info = (ushort)enemy_info.Count;

        writer.write_short(lenenemy_info);
        for (int i_enemy_info = 0; i_enemy_info < lenenemy_info; i_enemy_info++)
        {
            st.net.NetBase.enemy_info listData = enemy_info[i_enemy_info];
            listData.toBinary(writer);
        }
        ushort lenhistory_info_list = (ushort)history_info_list.Count;

        writer.write_short(lenhistory_info_list);
        for (int i_history_info_list = 0; i_history_info_list < lenhistory_info_list; i_history_info_list++)
        {
            st.net.NetBase.history_info_list listData = history_info_list[i_history_info_list];
            listData.toBinary(writer);
        }
        return(writer.data);
    }
Beispiel #2
0
    public override byte[] toBinary()
    {
        writer = new st.net.NetBase.ByteWriter();
        writer.write_int(star_num);
        writer.write_int(time);
        ushort lenreward_list = (ushort)reward_list.Count;

        writer.write_short(lenreward_list);
        for (int i_reward_list = 0; i_reward_list < lenreward_list; i_reward_list++)
        {
            st.net.NetBase.reward_list listData = reward_list[i_reward_list];
            listData.toBinary(writer);
        }
        writer.write_int(scene_type);
        ushort lenteam_reward_list = (ushort)team_reward_list.Count;

        writer.write_short(lenteam_reward_list);
        for (int i_team_reward_list = 0; i_team_reward_list < lenteam_reward_list; i_team_reward_list++)
        {
            st.net.NetBase.team_reward_list listData = team_reward_list[i_team_reward_list];
            listData.toBinary(writer);
        }
        writer.write_int(kill_boss_num);
        return(writer.data);
    }
Beispiel #3
0
    public override byte[] toBinary()
    {
        writer = new st.net.NetBase.ByteWriter();
        writer.write_int(rank);
        writer.write_int(surplus_time);
        writer.write_int(challenge_num);
        writer.write_int(reward_countdown);
        writer.write_int(state);
        ushort lenrobot_list = (ushort)robot_list.Count;

        writer.write_short(lenrobot_list);
        for (int i_robot_list = 0; i_robot_list < lenrobot_list; i_robot_list++)
        {
            st.net.NetBase.robot_list listData = robot_list[i_robot_list];
            listData.toBinary(writer);
        }
        ushort lenlog_list = (ushort)log_list.Count;

        writer.write_short(lenlog_list);
        for (int i_log_list = 0; i_log_list < lenlog_list; i_log_list++)
        {
            st.net.NetBase.log_list listData = log_list[i_log_list];
            listData.toBinary(writer);
        }
        writer.write_int(buy_challenge_times);
        writer.write_int(reward_rank);
        return(writer.data);
    }
    public override byte[] toBinary()
    {
        writer = new st.net.NetBase.ByteWriter();
        writer.write_int(uid);
        writer.write_str(name);
        writer.write_int(lev);
        writer.write_int(prof);
        ushort lenmodel_clothes_id = (ushort)model_clothes_id.Count;

        writer.write_short(lenmodel_clothes_id);
        for (int i_model_clothes_id = 0; i_model_clothes_id < lenmodel_clothes_id; i_model_clothes_id++)
        {
            int listData = model_clothes_id[i_model_clothes_id];
            writer.write_int(listData);
        }
        writer.write_int(wing_id);
        writer.write_int(wing_lev);
        ushort lentarget_equip_list = (ushort)target_equip_list.Count;

        writer.write_short(lentarget_equip_list);
        for (int i_target_equip_list = 0; i_target_equip_list < lentarget_equip_list; i_target_equip_list++)
        {
            st.net.NetBase.item_des listData = target_equip_list[i_target_equip_list];
            listData.toBinary(writer);
        }
        return(writer.data);
    }
Beispiel #5
0
    public override byte[] toBinary()
    {
        writer = new st.net.NetBase.ByteWriter();
        writer.write_int(liveness_guild);
        writer.write_int(liveness_self);
        ushort lenreward_list = (ushort)reward_list.Count;

        writer.write_short(lenreward_list);
        for (int i_reward_list = 0; i_reward_list < lenreward_list; i_reward_list++)
        {
            uint listData = reward_list[i_reward_list];
            writer.write_int(listData);
        }
        ushort lenmember_info_list = (ushort)member_info_list.Count;

        writer.write_short(lenmember_info_list);
        for (int i_member_info_list = 0; i_member_info_list < lenmember_info_list; i_member_info_list++)
        {
            st.net.NetBase.guild_liveness_member_info listData = member_info_list[i_member_info_list];
            listData.toBinary(writer);
        }
        ushort lentask_list = (ushort)task_list.Count;

        writer.write_short(lentask_list);
        for (int i_task_list = 0; i_task_list < lentask_list; i_task_list++)
        {
            st.net.NetBase.guild_liveness_task_info listData = task_list[i_task_list];
            listData.toBinary(writer);
        }
        return(writer.data);
    }
    public override byte[] toBinary()
    {
        writer = new st.net.NetBase.ByteWriter();
        writer.write_int(index);
        writer.write_str(champion);
        writer.write_int(state);
        ushort lenguild_battle_group_one = (ushort)guild_battle_group_one.Count;

        writer.write_short(lenguild_battle_group_one);
        for (int i_guild_battle_group_one = 0; i_guild_battle_group_one < lenguild_battle_group_one; i_guild_battle_group_one++)
        {
            st.net.NetBase.guild_battle_group_info_list listData = guild_battle_group_one[i_guild_battle_group_one];
            listData.toBinary(writer);
        }
        ushort lenguild_battle_group_two = (ushort)guild_battle_group_two.Count;

        writer.write_short(lenguild_battle_group_two);
        for (int i_guild_battle_group_two = 0; i_guild_battle_group_two < lenguild_battle_group_two; i_guild_battle_group_two++)
        {
            st.net.NetBase.guild_battle_group_info_list listData = guild_battle_group_two[i_guild_battle_group_two];
            listData.toBinary(writer);
        }
        ushort lenguild_battle_group_three = (ushort)guild_battle_group_three.Count;

        writer.write_short(lenguild_battle_group_three);
        for (int i_guild_battle_group_three = 0; i_guild_battle_group_three < lenguild_battle_group_three; i_guild_battle_group_three++)
        {
            st.net.NetBase.guild_battle_group_info_list listData = guild_battle_group_three[i_guild_battle_group_three];
            listData.toBinary(writer);
        }
        return(writer.data);
    }
Beispiel #7
0
    public override byte[] toBinary()
    {
        writer = new st.net.NetBase.ByteWriter();
        writer.write_int(type);
        writer.write_int(send_uid);
        writer.write_str(name);
        writer.write_str(receive_name);
        writer.write_int(vip_lev);
        writer.write_int(prof);
        writer.write_str(content);
        writer.write_int(scene);
        writer.write_int(x);
        writer.write_int(y);
        writer.write_int(z);
        writer.write_int(sort);
        writer.write_int(time);
        writer.write_int(item_type);
        ushort lenitem = (ushort)item.Count;

        writer.write_short(lenitem);
        for (int i_item = 0; i_item < lenitem; i_item++)
        {
            st.net.NetBase.item_des listData = item[i_item];
            listData.toBinary(writer);
        }
        ushort lencontent_info = (ushort)content_info.Count;

        writer.write_short(lencontent_info);
        for (int i_content_info = 0; i_content_info < lencontent_info; i_content_info++)
        {
            int listData = content_info[i_content_info];
            writer.write_int(listData);
        }
        return(writer.data);
    }
Beispiel #8
0
    public override byte[] toBinary()
    {
        writer = new st.net.NetBase.ByteWriter();
        writer.write_int(id);
        writer.write_str(name);
        writer.write_int(level);
        writer.write_long(exp);
        writer.write_int(prof);
        writer.write_int(cur_hp);
        writer.write_int(cur_mp);
        ushort lenproperty_list = (ushort)property_list.Count;

        writer.write_short(lenproperty_list);
        for (int i_property_list = 0; i_property_list < lenproperty_list; i_property_list++)
        {
            st.net.NetBase.property listData = property_list[i_property_list];
            listData.toBinary(writer);
        }
        ushort lenequip_id_list = (ushort)equip_id_list.Count;

        writer.write_short(lenequip_id_list);
        for (int i_equip_id_list = 0; i_equip_id_list < lenequip_id_list; i_equip_id_list++)
        {
            uint listData = equip_id_list[i_equip_id_list];
            writer.write_int(listData);
        }
        writer.write_int(camp);
        ushort lenresource_list = (ushort)resource_list.Count;

        writer.write_short(lenresource_list);
        for (int i_resource_list = 0; i_resource_list < lenresource_list; i_resource_list++)
        {
            st.net.NetBase.resource_list listData = resource_list[i_resource_list];
            listData.toBinary(writer);
        }
        writer.write_str(guild_name);
        ushort lenmodel_clothes_id = (ushort)model_clothes_id.Count;

        writer.write_short(lenmodel_clothes_id);
        for (int i_model_clothes_id = 0; i_model_clothes_id < lenmodel_clothes_id; i_model_clothes_id++)
        {
            int listData = model_clothes_id[i_model_clothes_id];
            writer.write_int(listData);
        }
        writer.write_int(title_id);
        writer.write_int(sla);
        writer.write_int(magic_weapon_id);
        writer.write_int(magic_strength_lev);
        writer.write_int(magic_strength_star);
        writer.write_int(fiight_score);
        writer.write_int(vip_lev);
        writer.write_int(guild_id);
        return(writer.data);
    }
Beispiel #9
0
    public override byte[] toBinary()
    {
        writer = new st.net.NetBase.ByteWriter();
        writer.write_short(used);
        ushort lentitles = (ushort)titles.Count;

        writer.write_short(lentitles);
        for (int i_titles = 0; i_titles < lentitles; i_titles++)
        {
            st.net.NetBase.title_obj listData = titles[i_titles];
            listData.toBinary(writer);
        }
        return(writer.data);
    }
Beispiel #10
0
    public override byte[] toBinary()
    {
        writer = new st.net.NetBase.ByteWriter();
        writer.write_int(uid);
        writer.write_str(name);
        writer.write_int(battle);
        writer.write_int(lev);
        writer.write_int(vip_lev);
        writer.write_int(prof);
        writer.write_str(guild_name);
        writer.write_int(slaughter);
        ushort lentarget_property = (ushort)target_property.Count;

        writer.write_short(lentarget_property);
        for (int i_target_property = 0; i_target_property < lentarget_property; i_target_property++)
        {
            st.net.NetBase.property listData = target_property[i_target_property];
            listData.toBinary(writer);
        }
        writer.write_int(luck_num);
        ushort lentarget_skill = (ushort)target_skill.Count;

        writer.write_short(lentarget_skill);
        for (int i_target_skill = 0; i_target_skill < lentarget_skill; i_target_skill++)
        {
            st.net.NetBase.normal_skill_list listData = target_skill[i_target_skill];
            listData.toBinary(writer);
        }
        ushort lenmodel_clothes_id = (ushort)model_clothes_id.Count;

        writer.write_short(lenmodel_clothes_id);
        for (int i_model_clothes_id = 0; i_model_clothes_id < lenmodel_clothes_id; i_model_clothes_id++)
        {
            int listData = model_clothes_id[i_model_clothes_id];
            writer.write_int(listData);
        }
        writer.write_int(wing_id);
        writer.write_int(wing_lev);
        ushort lentarget_equip_list = (ushort)target_equip_list.Count;

        writer.write_short(lentarget_equip_list);
        for (int i_target_equip_list = 0; i_target_equip_list < lentarget_equip_list; i_target_equip_list++)
        {
            st.net.NetBase.item_des listData = target_equip_list[i_target_equip_list];
            listData.toBinary(writer);
        }
        return(writer.data);
    }
Beispiel #11
0
    public override byte[] toBinary()
    {
        writer = new st.net.NetBase.ByteWriter();
        writer.write_int(oid);
        writer.write_byte(obj_sort);
        writer.write_int(skill);
        writer.write_int(lev);
        writer.write_int(rune);
        writer.write_byte(effect_sort);
        writer.write_float(x);
        writer.write_float(y);
        writer.write_float(z);
        writer.write_float(dir);
        writer.write_int(target_id);
        writer.write_float(target_x);
        writer.write_float(target_y);
        writer.write_float(target_z);
        writer.write_float(shift_x);
        writer.write_float(shift_y);
        writer.write_float(shift_z);
        ushort leneffect_list = (ushort)effect_list.Count;

        writer.write_short(leneffect_list);
        for (int i_effect_list = 0; i_effect_list < leneffect_list; i_effect_list++)
        {
            st.net.NetBase.skill_effect listData = effect_list[i_effect_list];
            listData.toBinary(writer);
        }
        return(writer.data);
    }
    public override byte[] toBinary()
    {
        writer = new st.net.NetBase.ByteWriter();
        ushort lenunderground_palace_boss = (ushort)underground_palace_boss.Count;

        writer.write_short(lenunderground_palace_boss);
        for (int i_underground_palace_boss = 0; i_underground_palace_boss < lenunderground_palace_boss; i_underground_palace_boss++)
        {
            st.net.NetBase.boss_challenge listData = underground_palace_boss[i_underground_palace_boss];
            listData.toBinary(writer);
        }
        ushort lenscene_boss = (ushort)scene_boss.Count;

        writer.write_short(lenscene_boss);
        for (int i_scene_boss = 0; i_scene_boss < lenscene_boss; i_scene_boss++)
        {
            st.net.NetBase.boss_challenge listData = scene_boss[i_scene_boss];
            listData.toBinary(writer);
        }
        ushort lenseal_boss = (ushort)seal_boss.Count;

        writer.write_short(lenseal_boss);
        for (int i_seal_boss = 0; i_seal_boss < lenseal_boss; i_seal_boss++)
        {
            st.net.NetBase.boss_challenge listData = seal_boss[i_seal_boss];
            listData.toBinary(writer);
        }
        ushort lensmeltters_boss = (ushort)smeltters_boss.Count;

        writer.write_short(lensmeltters_boss);
        for (int i_smeltters_boss = 0; i_smeltters_boss < lensmeltters_boss; i_smeltters_boss++)
        {
            st.net.NetBase.boss_challenge listData = smeltters_boss[i_smeltters_boss];
            listData.toBinary(writer);
        }
        ushort lenli_smeltters_boss = (ushort)li_smeltters_boss.Count;

        writer.write_short(lenli_smeltters_boss);
        for (int i_li_smeltters_boss = 0; i_li_smeltters_boss < lenli_smeltters_boss; i_li_smeltters_boss++)
        {
            st.net.NetBase.boss_challenge listData = li_smeltters_boss[i_li_smeltters_boss];
            listData.toBinary(writer);
        }
        return(writer.data);
    }
Beispiel #13
0
    public override byte[] toBinary()
    {
        writer = new st.net.NetBase.ByteWriter();
        writer.write_byte(type);
        writer.write_byte(page);
        ushort lenranklist = (ushort)ranklist.Count;

        writer.write_short(lenranklist);
        for (int i_ranklist = 0; i_ranklist < lenranklist; i_ranklist++)
        {
            st.net.NetBase.rank_info_base listData = ranklist[i_ranklist];
            listData.toBinary(writer);
        }
        writer.write_short(rank);
        writer.write_int(value1);
        writer.write_int(value2);
        return(writer.data);
    }
Beispiel #14
0
 public override byte[] toBinary()
 {
     writer = new st.net.NetBase.ByteWriter();
     writer.write_int(uid);
     writer.write_short(sort);
     writer.write_int(int_data);
     writer.write_str(str_data);
     return(writer.data);
 }
Beispiel #15
0
    public override byte[] toBinary()
    {
        writer = new st.net.NetBase.ByteWriter();
        ushort lenply_list = (ushort)ply_list.Count;

        writer.write_short(lenply_list);
        for (int i_ply_list = 0; i_ply_list < lenply_list; i_ply_list++)
        {
            st.net.NetBase.scene_ply listData = ply_list[i_ply_list];
            listData.toBinary(writer);
        }
        ushort lenentourage_list = (ushort)entourage_list.Count;

        writer.write_short(lenentourage_list);
        for (int i_entourage_list = 0; i_entourage_list < lenentourage_list; i_entourage_list++)
        {
            st.net.NetBase.scene_entourage listData = entourage_list[i_entourage_list];
            listData.toBinary(writer);
        }
        return(writer.data);
    }
	public override byte[] toBinary()
	{
		writer = new st.net.NetBase.ByteWriter();
		ushort lentrials = (ushort)trials.Count;
		writer.write_short(lentrials);
		for(int i_trials = 0 ; i_trials < lentrials ; i_trials ++)
		{
			st.net.NetBase.trial_nums listData = trials[i_trials];
			listData.toBinary(writer);
		}
		return writer.data;
	}
    public override byte[] toBinary()
    {
        writer = new st.net.NetBase.ByteWriter();
        ushort lenfairyland_general = (ushort)fairyland_general.Count;

        writer.write_short(lenfairyland_general);
        for (int i_fairyland_general = 0; i_fairyland_general < lenfairyland_general; i_fairyland_general++)
        {
            st.net.NetBase.general_list listData = fairyland_general[i_fairyland_general];
            listData.toBinary(writer);
        }
        ushort lendemon_general = (ushort)demon_general.Count;

        writer.write_short(lendemon_general);
        for (int i_demon_general = 0; i_demon_general < lendemon_general; i_demon_general++)
        {
            st.net.NetBase.general_list listData = demon_general[i_demon_general];
            listData.toBinary(writer);
        }
        return(writer.data);
    }
    public override byte[] toBinary()
    {
        writer = new st.net.NetBase.ByteWriter();
        ushort lenemptys = (ushort)emptys.Count;

        writer.write_short(lenemptys);
        for (int i_emptys = 0; i_emptys < lenemptys; i_emptys++)
        {
            int listData = emptys[i_emptys];
            writer.write_int(listData);
        }
        ushort lenguld_items = (ushort)guld_items.Count;

        writer.write_short(lenguld_items);
        for (int i_guld_items = 0; i_guld_items < lenguld_items; i_guld_items++)
        {
            st.net.NetBase.item_des listData = guld_items[i_guld_items];
            listData.toBinary(writer);
        }
        return(writer.data);
    }
Beispiel #19
0
    public override byte[] toBinary()
    {
        writer = new st.net.NetBase.ByteWriter();
        ushort lenempty_bags = (ushort)empty_bags.Count;

        writer.write_short(lenempty_bags);
        for (int i_empty_bags = 0; i_empty_bags < lenempty_bags; i_empty_bags++)
        {
            int listData = empty_bags[i_empty_bags];
            writer.write_int(listData);
        }
        ushort lenitem_list = (ushort)item_list.Count;

        writer.write_short(lenitem_list);
        for (int i_item_list = 0; i_item_list < lenitem_list; i_item_list++)
        {
            st.net.NetBase.item_des listData = item_list[i_item_list];
            listData.toBinary(writer);
        }
        return(writer.data);
    }
Beispiel #20
0
    public override byte[] toBinary()
    {
        writer = new st.net.NetBase.ByteWriter();
        ushort lensign_list = (ushort)sign_list.Count;

        writer.write_short(lensign_list);
        for (int i_sign_list = 0; i_sign_list < lensign_list; i_sign_list++)
        {
            st.net.NetBase.sign_list listData = sign_list[i_sign_list];
            listData.toBinary(writer);
        }
        ushort lensign_rewards_list = (ushort)sign_rewards_list.Count;

        writer.write_short(lensign_rewards_list);
        for (int i_sign_rewards_list = 0; i_sign_rewards_list < lensign_rewards_list; i_sign_rewards_list++)
        {
            st.net.NetBase.sign_rewards_list listData = sign_rewards_list[i_sign_rewards_list];
            listData.toBinary(writer);
        }
        return(writer.data);
    }
Beispiel #21
0
    public override byte[] toBinary()
    {
        writer = new st.net.NetBase.ByteWriter();
        ushort lenreward_list = (ushort)reward_list.Count;

        writer.write_short(lenreward_list);
        for (int i_reward_list = 0; i_reward_list < lenreward_list; i_reward_list++)
        {
            st.net.NetBase.brother_reward_info listData = reward_list[i_reward_list];
            listData.toBinary(writer);
        }
        ushort lentask_finish_list = (ushort)task_finish_list.Count;

        writer.write_short(lentask_finish_list);
        for (int i_task_finish_list = 0; i_task_finish_list < lentask_finish_list; i_task_finish_list++)
        {
            st.net.NetBase.sworn_task_finish_info listData = task_finish_list[i_task_finish_list];
            listData.toBinary(writer);
        }
        return(writer.data);
    }
Beispiel #22
0
    public override byte[] toBinary()
    {
        writer = new st.net.NetBase.ByteWriter();
        ushort lentask_surround = (ushort)task_surround.Count;

        writer.write_short(lentask_surround);
        for (int i_task_surround = 0; i_task_surround < lentask_surround; i_task_surround++)
        {
            st.net.NetBase.task_surround_info listData = task_surround[i_task_surround];
            listData.toBinary(writer);
        }
        return(writer.data);
    }
Beispiel #23
0
    public override byte[] toBinary()
    {
        writer = new st.net.NetBase.ByteWriter();
        ushort lenget_success_list = (ushort)get_success_list.Count;

        writer.write_short(lenget_success_list);
        for (int i_get_success_list = 0; i_get_success_list < lenget_success_list; i_get_success_list++)
        {
            st.net.NetBase.get_success_list listData = get_success_list[i_get_success_list];
            listData.toBinary(writer);
        }
        return(writer.data);
    }
Beispiel #24
0
    public override byte[] toBinary()
    {
        writer = new st.net.NetBase.ByteWriter();
        ushort lenteam_info = (ushort)team_info.Count;

        writer.write_short(lenteam_info);
        for (int i_team_info = 0; i_team_info < lenteam_info; i_team_info++)
        {
            st.net.NetBase.team_info listData = team_info[i_team_info];
            listData.toBinary(writer);
        }
        return(writer.data);
    }
Beispiel #25
0
    public override byte[] toBinary()
    {
        writer = new st.net.NetBase.ByteWriter();
        ushort lenid_list = (ushort)id_list.Count;

        writer.write_short(lenid_list);
        for (int i_id_list = 0; i_id_list < lenid_list; i_id_list++)
        {
            int listData = id_list[i_id_list];
            writer.write_int(listData);
        }
        return(writer.data);
    }
Beispiel #26
0
    public override byte[] toBinary()
    {
        writer = new st.net.NetBase.ByteWriter();
        ushort lenguild_copy_damage_ranking = (ushort)guild_copy_damage_ranking.Count;

        writer.write_short(lenguild_copy_damage_ranking);
        for (int i_guild_copy_damage_ranking = 0; i_guild_copy_damage_ranking < lenguild_copy_damage_ranking; i_guild_copy_damage_ranking++)
        {
            st.net.NetBase.guild_copy_damage_ranking listData = guild_copy_damage_ranking[i_guild_copy_damage_ranking];
            listData.toBinary(writer);
        }
        return(writer.data);
    }
Beispiel #27
0
    public override byte[] toBinary()
    {
        writer = new st.net.NetBase.ByteWriter();
        ushort lenguild_skills = (ushort)guild_skills.Count;

        writer.write_short(lenguild_skills);
        for (int i_guild_skills = 0; i_guild_skills < lenguild_skills; i_guild_skills++)
        {
            int listData = guild_skills[i_guild_skills];
            writer.write_int(listData);
        }
        return(writer.data);
    }
    public override byte[] toBinary()
    {
        writer = new st.net.NetBase.ByteWriter();
        ushort lencopy_sweep = (ushort)copy_sweep.Count;

        writer.write_short(lencopy_sweep);
        for (int i_copy_sweep = 0; i_copy_sweep < lencopy_sweep; i_copy_sweep++)
        {
            st.net.NetBase.copy_sweep_list listData = copy_sweep[i_copy_sweep];
            listData.toBinary(writer);
        }
        return(writer.data);
    }
    public override byte[] toBinary()
    {
        writer = new st.net.NetBase.ByteWriter();
        ushort lenteam_member_list = (ushort)team_member_list.Count;

        writer.write_short(lenteam_member_list);
        for (int i_team_member_list = 0; i_team_member_list < lenteam_member_list; i_team_member_list++)
        {
            st.net.NetBase.team_member_list listData = team_member_list[i_team_member_list];
            listData.toBinary(writer);
        }
        return(writer.data);
    }
Beispiel #30
0
    public override byte[] toBinary()
    {
        writer = new st.net.NetBase.ByteWriter();
        ushort lenitems = (ushort)items.Count;

        writer.write_short(lenitems);
        for (int i_items = 0; i_items < lenitems; i_items++)
        {
            st.net.NetBase.item_des listData = items[i_items];
            listData.toBinary(writer);
        }
        return(writer.data);
    }