A9VG电玩部落论坛

 找回密码
 注册
搜索
楼主: hysby

求善良的程序猿出教程,如何将suite上的DEMO游戏打包

[复制链接]
该用户已被禁言

精华
0
帖子
53
威望
0 点
积分
54 点
种子
0 点
注册时间
2010-10-15
最后登录
2020-1-10
发表于 2012-4-20 21:58  ·  新加坡 | 显示全部楼层
其实我看了半天API,完全没发现有IO相关的class和function.........

审判者

究竟怎样的人生才能让人喜欢上命运这个词

精华
5
帖子
11208
威望
10 点
积分
12714 点
种子
8 点
注册时间
2005-2-14
最后登录
2024-11-22
发表于 2012-4-21 00:27  ·  湖北 | 显示全部楼层
baliwan 发表于 2012-4-20 21:58
其实我看了半天API,完全没发现有IO相关的class和function.........

  1. namespace System
  2. {
  3.         public static class Console
  4.         {
  5.                 internal static TextWriter stdout;
  6.                 private static TextWriter stderr;
  7.                 private static TextReader stdin;
  8.                 public static TextWriter Error
  9.                 {
  10.                         get
  11.                         {
  12.                                 return Console.stderr;
  13.                         }
  14.                 }
  15.                 public static TextWriter Out
  16.                 {
  17.                         get
  18.                         {
  19.                                 return Console.stdout;
  20.                         }
  21.                 }
  22.                 public static TextReader In
  23.                 {
  24.                         get
  25.                         {
  26.                                 return Console.stdin;
  27.                         }
  28.                 }
  29.                 private static void SetupStreams (Encoding inputEncoding, Encoding outputEncoding)
  30.                 {
  31.                         Console.stderr = new UnexceptionalStreamWriter (Console.OpenStandardError (0), outputEncoding);
  32.                         ((StreamWriter)Console.stderr).AutoFlush = true;
  33.                         Console.stderr = TextWriter.Synchronized (Console.stderr, true);
  34.                         Console.stdout = new UnexceptionalStreamWriter (Console.OpenStandardOutput (0), outputEncoding);
  35.                         ((StreamWriter)Console.stdout).AutoFlush = true;
  36.                         Console.stdout = TextWriter.Synchronized (Console.stdout, true);
  37.                         Console.stdin = new UnexceptionalStreamReader (Console.OpenStandardInput (0), inputEncoding);
  38.                         Console.stdin = TextReader.Synchronized (Console.stdin);
  39.                         GC.SuppressFinalize (Console.stdout);
  40.                         GC.SuppressFinalize (Console.stderr);
  41.                         GC.SuppressFinalize (Console.stdin);
  42.                 }
  43.                 private static Stream Open (IntPtr handle, FileAccess access, int bufferSize)
  44.                 {
  45.                         Stream result;
  46.                         try
  47.                         {
  48.                                 result = new FileStream (handle, access, false, bufferSize, false, bufferSize == 0);
  49.                         }
  50.                         catch (IOException)
  51.                         {
  52.                                 result = new NullStream ();
  53.                         }
  54.                         return result;
  55.                 }
  56.                 public static Stream OpenStandardError ()
  57.                 {
  58.                         return Console.OpenStandardError (0);
  59.                 }
  60.                 [SecuritySafeCritical ]
  61.                 public static Stream OpenStandardError (int bufferSize)
  62.                 {
  63.                         return Console.Open (MonoIO.ConsoleError, FileAccess.Write, bufferSize);
  64.                 }
  65.                 public static Stream OpenStandardInput ()
  66.                 {
  67.                         return Console.OpenStandardInput (0);
  68.                 }
  69.                 [SecuritySafeCritical ]
  70.                 public static Stream OpenStandardInput (int bufferSize)
  71.                 {
  72.                         return Console.Open (MonoIO.ConsoleInput, FileAccess.Read, bufferSize);
  73.                 }
  74.                 public static Stream OpenStandardOutput ()
  75.                 {
  76.                         return Console.OpenStandardOutput (0);
  77.                 }
  78.                 [SecuritySafeCritical ]
  79.                 public static Stream OpenStandardOutput (int bufferSize)
  80.                 {
  81.                         return Console.Open (MonoIO.ConsoleOutput, FileAccess.Write, bufferSize);
  82.                 }
  83.                 [SecurityCritical ]
  84.                 public static void SetError (TextWriter newError)
  85.                 {
  86.                         if (newError == null)
  87.                         {
  88.                                 throw new ArgumentNullException ("newError");
  89.                         }
  90.                         Console.stderr = newError;
  91.                 }
  92.                 [SecurityCritical ]
  93.                 public static void SetIn (TextReader newIn)
  94.                 {
  95.                         if (newIn == null)
  96.                         {
  97.                                 throw new ArgumentNullException ("newIn");
  98.                         }
  99.                         Console.stdin = newIn;
  100.                 }
  101.                 [SecurityCritical ]
  102.                 public static void SetOut (TextWriter newOut)
  103.                 {
  104.                         if (newOut == null)
  105.                         {
  106.                                 throw new ArgumentNullException ("newOut");
  107.                         }
  108.                         Console.stdout = newOut;
  109.                 }
  110.                 public static void Write (bool value)
  111.                 {
  112.                         Console.stdout.Write (value);
  113.                 }
  114.                 public static void Write (char value)
  115.                 {
  116.                         Console.stdout.Write (value);
  117.                 }
  118.                 public static void Write (char[] buffer)
  119.                 {
  120.                         Console.stdout.Write (buffer);
  121.                 }
  122.                 public static void Write (decimal value)
  123.                 {
  124.                         Console.stdout.Write (value);
  125.                 }
  126.                 public static void Write (double value)
  127.                 {
  128.                         Console.stdout.Write (value);
  129.                 }
  130.                 public static void Write (int value)
  131.                 {
  132.                         Console.stdout.Write (value);
  133.                 }
  134.                 public static void Write (long value)
  135.                 {
  136.                         Console.stdout.Write (value);
  137.                 }
  138.                 public static void Write (object value)
  139.                 {
  140.                         Console.stdout.Write (value);
  141.                 }
  142.                 public static void Write (float value)
  143.                 {
  144.                         Console.stdout.Write (value);
  145.                 }
  146.                 public static void Write (string value)
  147.                 {
  148.                         Console.stdout.Write (value);
  149.                 }
  150.                 [CLSCompliant (false)]
  151.                 public static void Write (uint value)
  152.                 {
  153.                         Console.stdout.Write (value);
  154.                 }
  155.                 [CLSCompliant (false)]
  156.                 public static void Write (ulong value)
  157.                 {
  158.                         Console.stdout.Write (value);
  159.                 }
  160.                 public static void Write (string format, object arg0)
  161.                 {
  162.                         Console.stdout.Write (format, arg0);
  163.                 }
  164.                 public static void Write (string format, params object[] arg)
  165.                 {
  166.                         if (arg == null)
  167.                         {
  168.                                 Console.stdout.Write (format);
  169.                         }
  170.                         else
  171.                         {
  172.                                 Console.stdout.Write (format, arg);
  173.                         }
  174.                 }
  175.                 public static void Write (char[] buffer, int index, int count)
  176.                 {
  177.                         Console.stdout.Write (buffer, index, count);
  178.                 }
  179.                 public static void Write (string format, object arg0, object arg1)
  180.                 {
  181.                         Console.stdout.Write (format, arg0, arg1);
  182.                 }
  183.                 public static void Write (string format, object arg0, object arg1, object arg2)
  184.                 {
  185.                         Console.stdout.Write (format, arg0, arg1, arg2);
  186.                 }
  187.                 [SecurityCritical , CLSCompliant (false)]
  188.                 public static void Write (string format, object arg0, object arg1, object arg2, object arg3, __arglist)
  189.                 {
  190.                         ArgIterator argIterator = new ArgIterator (__arglist);
  191.                         int remainingCount = argIterator.GetRemainingCount ();
  192.                         object[] array = new object[remainingCount + 4];
  193.                         array [0] = arg0;
  194.                         array [1] = arg1;
  195.                         array [2] = arg2;
  196.                         array [3] = arg3;
  197.                         for (int i = 0; i < remainingCount; i++)
  198.                         {
  199.                                 TypedReference nextArg = argIterator.GetNextArg ();
  200.                                 array [i + 4] = TypedReference.ToObject (nextArg);
  201.                         }
  202.                         Console.stdout.Write (string.Format (format, array));
  203.                 }
  204.                 public static void WriteLine ()
  205.                 {
  206.                         Console.stdout.WriteLine ();
  207.                 }
  208.                 public static void WriteLine (bool value)
  209.                 {
  210.                         Console.stdout.WriteLine (value);
  211.                 }
  212.                 public static void WriteLine (char value)
  213.                 {
  214.                         Console.stdout.WriteLine (value);
  215.                 }
  216.                 public static void WriteLine (char[] buffer)
  217.                 {
  218.                         Console.stdout.WriteLine (buffer);
  219.                 }
  220.                 public static void WriteLine (decimal value)
  221.                 {
  222.                         Console.stdout.WriteLine (value);
  223.                 }
  224.                 public static void WriteLine (double value)
  225.                 {
  226.                         Console.stdout.WriteLine (value);
  227.                 }
  228.                 public static void WriteLine (int value)
  229.                 {
  230.                         Console.stdout.WriteLine (value);
  231.                 }
  232.                 public static void WriteLine (long value)
  233.                 {
  234.                         Console.stdout.WriteLine (value);
  235.                 }
  236.                 public static void WriteLine (object value)
  237.                 {
  238.                         Console.stdout.WriteLine (value);
  239.                 }
  240.                 public static void WriteLine (float value)
  241.                 {
  242.                         Console.stdout.WriteLine (value);
  243.                 }
  244.                 public static void WriteLine (string value)
  245.                 {
  246.                         Console.stdout.WriteLine (value);
  247.                 }
  248.                 [CLSCompliant (false)]
  249.                 public static void WriteLine (uint value)
  250.                 {
  251.                         Console.stdout.WriteLine (value);
  252.                 }
  253.                 [CLSCompliant (false)]
  254.                 public static void WriteLine (ulong value)
  255.                 {
  256.                         Console.stdout.WriteLine (value);
  257.                 }
  258.                 public static void WriteLine (string format, object arg0)
  259.                 {
  260.                         Console.stdout.WriteLine (format, arg0);
  261.                 }
  262.                 public static void WriteLine (string format, params object[] arg)
  263.                 {
  264.                         if (arg == null)
  265.                         {
  266.                                 Console.stdout.WriteLine (format);
  267.                         }
  268.                         else
  269.                         {
  270.                                 Console.stdout.WriteLine (format, arg);
  271.                         }
  272.                 }
  273.                 public static void WriteLine (char[] buffer, int index, int count)
  274.                 {
  275.                         Console.stdout.WriteLine (buffer, index, count);
  276.                 }
  277.                 public static void WriteLine (string format, object arg0, object arg1)
  278.                 {
  279.                         Console.stdout.WriteLine (format, arg0, arg1);
  280.                 }
  281.                 public static void WriteLine (string format, object arg0, object arg1, object arg2)
  282.                 {
  283.                         Console.stdout.WriteLine (format, arg0, arg1, arg2);
  284.                 }
  285.                 [CLSCompliant (false), SecurityCritical ]
  286.                 public static void WriteLine (string format, object arg0, object arg1, object arg2, object arg3, __arglist)
  287.                 {
  288.                         ArgIterator argIterator = new ArgIterator (__arglist);
  289.                         int remainingCount = argIterator.GetRemainingCount ();
  290.                         object[] array = new object[remainingCount + 4];
  291.                         array [0] = arg0;
  292.                         array [1] = arg1;
  293.                         array [2] = arg2;
  294.                         array [3] = arg3;
  295.                         for (int i = 0; i < remainingCount; i++)
  296.                         {
  297.                                 TypedReference nextArg = argIterator.GetNextArg ();
  298.                                 array [i + 4] = TypedReference.ToObject (nextArg);
  299.                         }
  300.                         Console.stdout.WriteLine (string.Format (format, array));
  301.                 }
  302.                 public static int Read ()
  303.                 {
  304.                         return Console.stdin.Read ();
  305.                 }
  306.                 public static string ReadLine ()
  307.                 {
  308.                         return Console.stdin.ReadLine ();
  309.                 }
  310.                 [SecuritySafeCritical ]
  311.                 static Console ()
  312.                 {
  313.                         Encoding inputEncoding;
  314.                         Encoding outputEncoding;
  315.                         if (Environment.IsRunningOnWindows)
  316.                         {
  317.                                 outputEncoding = (inputEncoding = Encoding.Default);
  318.                         }
  319.                         else
  320.                         {
  321.                                 int num = 0;
  322.                                 Encoding.InternalCodePage (ref num);
  323.                                 if (num != -1 && ((num & 268435455) == 3 || (num & 268435456) != 0))
  324.                                 {
  325.                                         outputEncoding = (inputEncoding = Encoding.UTF8Unmarked);
  326.                                 }
  327.                                 else
  328.                                 {
  329.                                         outputEncoding = (inputEncoding = Encoding.Default);
  330.                                 }
  331.                         }
  332.                         Console.SetupStreams (inputEncoding, outputEncoding);
  333.                 }
  334.         }
  335. }
复制代码
控制台当然是有的 只不过这个是底下那个调试控制台 并不是真正在PSV上显示
想在屏幕上打行字的话用SampleDraw.DrawText吧

  1.     public static void DrawText(string text, uint argb, Font font, int positionX, int positionY)
  2.     {
  3.         AddSprite(text, text, argb, font, positionX, positionY);
  4.         DrawSprite(text);
  5.     }

  6.     public static void DrawText(string text, uint argb, int positionX, int positionY)
  7.     {
  8.         AddSprite(text, text, argb, currentFont, positionX, positionY);
  9.         DrawSprite(text);
  10.     }
复制代码
该用户已被禁言

精华
0
帖子
53
威望
0 点
积分
54 点
种子
0 点
注册时间
2010-10-15
最后登录
2020-1-10
发表于 2012-4-21 11:54  ·  新加坡 | 显示全部楼层
tring 发表于 2012-4-21 00:27
控制台当然是有的 只不过这个是底下那个调试控制台 并不是真正在PSV上显示
想在屏幕上打行字的话用Sampl ...

谢谢回复哦。其实我是想读/写一个外部的文件什么的.比如说load一个jpeg或者txt什么的到program里。

审判者

究竟怎样的人生才能让人喜欢上命运这个词

精华
5
帖子
11208
威望
10 点
积分
12714 点
种子
8 点
注册时间
2005-2-14
最后登录
2024-11-22
发表于 2012-4-21 11:57  ·  湖北 | 显示全部楼层
baliwan 发表于 2012-4-21 11:54
谢谢回复哦。其实我是想读/写一个外部的文件什么的.比如说load一个jpeg或者txt什么的到program里。

全心全意封破解的SCE当然不可能给你文件系统接口……
或者应该说 你觉得现在PSV有什么方法把外部文件导到机器里?……
该用户已被禁言

精华
0
帖子
4588
威望
0 点
积分
5040 点
种子
5 点
注册时间
2006-1-24
最后登录
2021-4-24
 楼主| 发表于 2012-4-21 12:16  ·  上海 | 显示全部楼层
本帖最后由 hysby 于 2012-4-21 12:16 编辑

有个问题 为什么 不能再PSV上运行?我连接电脑;了,选了PSV那选项,但是run without rebug 运行后 psv 显示 could not be confimed~

精华
0
帖子
2
威望
0 点
积分
2 点
种子
0 点
注册时间
2012-3-17
最后登录
2013-8-9
发表于 2012-4-21 12:42  ·  黑龙江 | 显示全部楼层
tring 发表于 2012-4-21 11:57
全心全意封破解的SCE当然不可能给你文件系统接口……
或者应该说 你觉得现在PSV有什么方法把外部文件导到 ...

硬编码到程序源码里,然后传输到psv里,只能这样了

审判者

究竟怎样的人生才能让人喜欢上命运这个词

精华
5
帖子
11208
威望
10 点
积分
12714 点
种子
8 点
注册时间
2005-2-14
最后登录
2024-11-22
发表于 2012-4-21 12:47  ·  湖北 | 显示全部楼层
djp518 发表于 2012-4-21 12:42
硬编码到程序源码里,然后传输到psv里,只能这样了

让人回想到了早年DS和GBA的程序开发方式……一个ROM就是几本电子书……
该用户已被禁言

精华
0
帖子
53
威望
0 点
积分
54 点
种子
0 点
注册时间
2010-10-15
最后登录
2020-1-10
发表于 2012-4-21 21:27  ·  新加坡 | 显示全部楼层
tring 发表于 2012-4-21 11:57
全心全意封破解的SCE当然不可能给你文件系统接口……
或者应该说 你觉得现在PSV有什么方法把外部文件导到 ...

我猜导入应该不是问题吧。改后缀,从internet下载应该都是可以的。关键是还是没有 I/O API.

审判者

究竟怎样的人生才能让人喜欢上命运这个词

精华
5
帖子
11208
威望
10 点
积分
12714 点
种子
8 点
注册时间
2005-2-14
最后登录
2024-11-22
发表于 2012-4-21 21:29  ·  湖北 | 显示全部楼层
baliwan 发表于 2012-4-21 21:27
我猜导入应该不是问题吧。改后缀,从internet下载应该都是可以的。关键是还是没有 I/O API.

都是720P的MP4你如果编码不支持的话都是导入不到PSV里去的……
改后缀这种东西……你觉得可能么……
那种电脑不连网就不能往PSV里传数据的严格到***的链接装置你以为就让你改个后缀就把东西导进去了?……
该用户已被禁言

精华
0
帖子
53
威望
0 点
积分
54 点
种子
0 点
注册时间
2010-10-15
最后登录
2020-1-10
发表于 2012-4-21 22:23  ·  新加坡 | 显示全部楼层
tring 发表于 2012-4-21 21:29
都是720P的MP4你如果编码不支持的话都是导入不到PSV里去的……
改后缀这种东西……你觉得可能么……
那 ...

估计您要失望了,那个严格到2B的内容管理器还真能导入后缀是JPG的“txt”文件...
您需要登录后才可以回帖 登录 | 注册

本版积分规则

Archiver|手机版|A9VG电玩部落 川公网安备 51019002005286号

GMT+8, 2024-11-26 05:59 , Processed in 0.232152 second(s), 14 queries , Redis On.

Powered by Discuz! X3.4

Copyright © 2001-2020, Tencent Cloud.

返回顶部